From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id D4BB59A8A for ; Tue, 2 Feb 2016 07:57:25 +0100 (CET) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga103.jf.intel.com with ESMTP; 01 Feb 2016 22:57:27 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.22,383,1449561600"; d="scan'208";a="738862665" Received: from shvmail01.sh.intel.com ([10.239.29.42]) by orsmga003.jf.intel.com with ESMTP; 01 Feb 2016 22:57:23 -0800 Received: from shecgisg004.sh.intel.com (shecgisg004.sh.intel.com [10.239.29.89]) by shvmail01.sh.intel.com with ESMTP id u126vKXV007497; Tue, 2 Feb 2016 14:57:20 +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 u126vHOo011854; Tue, 2 Feb 2016 14:57:19 +0800 Received: (from wenzhuol@localhost) by shecgisg004.sh.intel.com (8.13.6/8.13.6/Submit) id u126vHrs011850; Tue, 2 Feb 2016 14:57:17 +0800 From: Wenzhuo Lu To: dev@dpdk.org Date: Tue, 2 Feb 2016 14:57:03 +0800 Message-Id: <1454396225-11784-6-git-send-email-wenzhuo.lu@intel.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1454396225-11784-1-git-send-email-wenzhuo.lu@intel.com> References: <1454051035-25757-1-git-send-email-wenzhuo.lu@intel.com> <1454396225-11784-1-git-send-email-wenzhuo.lu@intel.com> Subject: [dpdk-dev] [PATCH v2 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: Tue, 02 Feb 2016 06:57:26 -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 | 178 ++++++++++++++++++++++++++++++++++++ lib/librte_ether/rte_ethdev.h | 204 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 382 insertions(+) diff --git a/lib/librte_ether/rte_ethdev.c b/lib/librte_ether/rte_ethdev.c index 1b90e09..a5a398c 100644 --- a/lib/librte_ether/rte_ethdev.c +++ b/lib/librte_ether/rte_ethdev.c @@ -3300,3 +3300,181 @@ 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) +{ + 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); +} + +int +rte_eth_dev_l2_tunnel_insertion_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_insertion_disable, + -ENOTSUP); + return (*dev->dev_ops->l2_tunnel_insertion_disable)(dev, + l2_tunnel_type); +} + +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..ffb4993 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,41 @@ 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); +/**< @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); +/**< @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 +1507,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 +4023,158 @@ 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. + * + * @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); + + /** + * 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. + * + * @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); + + /** + * 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