From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by dpdk.org (Postfix) with ESMTP id 4F584C370 for ; Thu, 18 Feb 2016 03:46:31 +0100 (CET) Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga102.fm.intel.com with ESMTP; 17 Feb 2016 18:46:32 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.22,463,1449561600"; d="scan'208";a="905689067" Received: from shvmail01.sh.intel.com ([10.239.29.42]) by fmsmga001.fm.intel.com with ESMTP; 17 Feb 2016 18:46:32 -0800 Received: from shecgisg004.sh.intel.com (shecgisg004.sh.intel.com [10.239.29.89]) by shvmail01.sh.intel.com with ESMTP id u1I2kTbh002394; Thu, 18 Feb 2016 10:46:29 +0800 Received: from shecgisg004.sh.intel.com (localhost [127.0.0.1]) by shecgisg004.sh.intel.com (8.13.6/8.13.6/SuSE Linux 0.8) with ESMTP id u1I2kPwr002937; Thu, 18 Feb 2016 10:46:28 +0800 Received: (from wenzhuol@localhost) by shecgisg004.sh.intel.com (8.13.6/8.13.6/Submit) id u1I2kPhf002933; Thu, 18 Feb 2016 10:46:25 +0800 From: Wenzhuo Lu To: dev@dpdk.org Date: Thu, 18 Feb 2016 10:46:11 +0800 Message-Id: <1455763573-2867-6-git-send-email-wenzhuo.lu@intel.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1455763573-2867-1-git-send-email-wenzhuo.lu@intel.com> References: <1454051035-25757-1-git-send-email-wenzhuo.lu@intel.com> <1455763573-2867-1-git-send-email-wenzhuo.lu@intel.com> Subject: [dpdk-dev] [PATCH v4 5/7] lib/librte_ether: support new l2 tunnel operation X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 18 Feb 2016 02:46:33 -0000 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 --- 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 c5c12cb..6bc19d4 100644 --- a/lib/librte_ether/rte_ethdev.c +++ b/lib/librte_ether/rte_ethdev.c @@ -3298,3 +3298,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 709485a..d482f8c 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; }; /** @@ -3964,6 +4020,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