From patchwork Thu Jan 13 10:27:17 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob X-Patchwork-Id: 105780 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id C31E3A0093; Thu, 13 Jan 2022 11:28:10 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 487934271A; Thu, 13 Jan 2022 11:28:10 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id A85FB40150 for ; Thu, 13 Jan 2022 11:28:08 +0100 (CET) Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.16.1.2/8.16.1.2) with ESMTP id 20DALJiD029839; Thu, 13 Jan 2022 02:27:35 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=PFPcpxWJMrSpFgxu/LENm8F+Mn1DN9Lqp7aY10RBp74=; b=NdooVVwanNicieP4kBozIbkTgNdauQlYV30JHSk7SsDuzPdEbsImcc8iOkSeVqxCrBKX zcvIuwjotVxNS/ufFQUESwL2Slvmg6raiaLczKfnHRuBbckmVKcSIkYld5tGSd5QT9s5 jcVki6AoBKrIdlZq7HhVWzJrTEFjsWyB3pxYgWx8LBrThgUlug5GmQjZrUVnX44ScAyx d47XuOiR2pMWbMfe/Uh0pGlcZPvwlXBZ81kDk1rpdHjwTnJpU4/1AkxgfdGihUqOCbkK 9NxBIyDpTK0SZqIfKB6RsTCnjn4qDxVzS8nqWBRWd75b8oiDeJz/jEHhec1H9d8MWiei kw== Received: from dc5-exch02.marvell.com ([199.233.59.182]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 3djarn9kjy-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 13 Jan 2022 02:27:34 -0800 Received: from DC5-EXCH01.marvell.com (10.69.176.38) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Thu, 13 Jan 2022 02:27:32 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Thu, 13 Jan 2022 02:27:32 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id A0B643F7070; Thu, 13 Jan 2022 02:27:14 -0800 (PST) From: To: , Ray Kinsella , Thomas Monjalon , Ferruh Yigit , "Andrew Rybchenko" CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Jerin Jacob Subject: [dpdk-dev] [PATCH v2 1/2] ethdev: support queue-based priority flow control Date: Thu, 13 Jan 2022 15:57:17 +0530 Message-ID: <20220113102718.3167282-1-jerinj@marvell.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220109105851.734687-1-skori@marvell.com> References: <20220109105851.734687-1-skori@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: vu6WZvhuvW8dnUveif_nMFkAt5VAkL1h X-Proofpoint-ORIG-GUID: vu6WZvhuvW8dnUveif_nMFkAt5VAkL1h X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.11.62.513 definitions=2022-01-13_02,2022-01-13_01,2021-12-02_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Jerin Jacob Based on device support and use-case need, there are two different ways to enable PFC. The first case is the port level PFC configuration, in this case, rte_eth_dev_priority_flow_ctrl_set() API shall be used to configure the PFC, and PFC frames will be generated using based on VLAN TC value. The second case is the queue level PFC configuration, in this case, Any packet field content can be used to steer the packet to the specific queue using rte_flow or RSS and then use rte_eth_dev_priority_flow_ctrl_queue_set() to set the TC mapping on each queue. Based on congestion selected on the specific queue, configured TC shall be used to generate PFC frames. Operation of these modes are mutually exclusive, when driver sets non zero value for rte_eth_dev_info::pfc_queue_tc_max, application must use queue level PFC configuration via rte_eth_dev_priority_flow_ctrl_queue_set() API instead of port level PFC configuration via rte_eth_dev_priority_flow_ctrl_set() API to realize PFC configuration. This patch enables the configuration for second case a.k.a queue based PFC also updates rte_eth_dev_priority_flow_ctrl_set() implmentaion to adheher to rte_eth_dev_info::pfc_queue_tc_max handling. Also updated libabigail.abignore to ignore the update to reserved fields in rte_eth_dev_info. Signed-off-by: Jerin Jacob Signed-off-by: Sunil Kumar Kori --- A driver implemtion based on this API is at https://patches.dpdk.org/project/dpdk/patch/20220111081831.881374-1-skori@marvell.com/ RFC..v1 - Added queue based PFC config API instead port based v1..v2 - Updated libabigail.ignore as has_data_member_inserted_between = {offset_of(reserved_64s), end} - Updated doxygen comments of rte_eth_pfc_queue_conf devtools/libabigail.abignore | 5 ++ doc/guides/nics/features.rst | 5 +- doc/guides/rel_notes/release_22_03.rst | 3 + lib/ethdev/ethdev_driver.h | 6 +- lib/ethdev/rte_ethdev.c | 109 +++++++++++++++++++++++++ lib/ethdev/rte_ethdev.h | 83 ++++++++++++++++++- lib/ethdev/version.map | 3 + 7 files changed, 208 insertions(+), 6 deletions(-) diff --git a/devtools/libabigail.abignore b/devtools/libabigail.abignore index 4b676f317d..3bdecaaef0 100644 --- a/devtools/libabigail.abignore +++ b/devtools/libabigail.abignore @@ -11,3 +11,8 @@ ; Ignore generated PMD information strings [suppress_variable] name_regexp = _pmd_info$ + +;Ignore fields inserted in place of reserved fields of rte_eth_dev_info +[suppress_type] + name = rte_eth_dev_info + has_data_member_inserted_between = {offset_of(reserved_64s), end} diff --git a/doc/guides/nics/features.rst b/doc/guides/nics/features.rst index 27be2d2576..277a784f4e 100644 --- a/doc/guides/nics/features.rst +++ b/doc/guides/nics/features.rst @@ -379,9 +379,10 @@ Flow control Supports configuring link flow control. * **[implements] eth_dev_ops**: ``flow_ctrl_get``, ``flow_ctrl_set``, - ``priority_flow_ctrl_set``. + ``priority_flow_ctrl_set``, ``priority_flow_ctrl_queue_set``. * **[related] API**: ``rte_eth_dev_flow_ctrl_get()``, ``rte_eth_dev_flow_ctrl_set()``, - ``rte_eth_dev_priority_flow_ctrl_set()``. + ``rte_eth_dev_priority_flow_ctrl_set()``, ``rte_eth_dev_priority_flow_ctrl_queue_set()``. +* **[provides] rte_eth_dev_info**: ``pfc_queue_tc_max``. .. _nic_features_rate_limitation: diff --git a/doc/guides/rel_notes/release_22_03.rst b/doc/guides/rel_notes/release_22_03.rst index 6d99d1eaa9..b75c0356e6 100644 --- a/doc/guides/rel_notes/release_22_03.rst +++ b/doc/guides/rel_notes/release_22_03.rst @@ -55,6 +55,9 @@ New Features Also, make sure to start the actual text at the margin. ======================================================= +* **Added an API to enable queue based priority flow ctrl(PFC).** + + A new API, ``rte_eth_dev_priority_flow_ctrl_queue_set()``, was added. Removed Items ------------- diff --git a/lib/ethdev/ethdev_driver.h b/lib/ethdev/ethdev_driver.h index d95605a355..e0bbfe89d7 100644 --- a/lib/ethdev/ethdev_driver.h +++ b/lib/ethdev/ethdev_driver.h @@ -532,6 +532,9 @@ typedef int (*flow_ctrl_set_t)(struct rte_eth_dev *dev, /** @internal Setup priority flow control parameter on an Ethernet device. */ typedef int (*priority_flow_ctrl_set_t)(struct rte_eth_dev *dev, struct rte_eth_pfc_conf *pfc_conf); +/** @internal Queue setup for priority flow control parameter on an Ethernet device. */ +typedef int (*priority_flow_ctrl_queue_set_t)(struct rte_eth_dev *dev, + struct rte_eth_pfc_queue_conf *pfc_queue_conf); /** @internal Update RSS redirection table on an Ethernet device. */ typedef int (*reta_update_t)(struct rte_eth_dev *dev, @@ -1080,7 +1083,8 @@ struct eth_dev_ops { flow_ctrl_set_t flow_ctrl_set; /**< Setup flow control */ /** Setup priority flow control */ priority_flow_ctrl_set_t priority_flow_ctrl_set; - + /** Priority flow control queue setup */ + priority_flow_ctrl_queue_set_t priority_flow_ctrl_queue_set; /** Set Unicast Table Array */ eth_uc_hash_table_set_t uc_hash_table_set; /** Set Unicast hash bitmap */ diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c index a1d475a292..6def057720 100644 --- a/lib/ethdev/rte_ethdev.c +++ b/lib/ethdev/rte_ethdev.c @@ -3998,7 +3998,9 @@ int rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, struct rte_eth_pfc_conf *pfc_conf) { + struct rte_eth_dev_info dev_info; struct rte_eth_dev *dev; + int ret; RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); dev = &rte_eth_devices[port_id]; @@ -4010,6 +4012,17 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, return -EINVAL; } + ret = rte_eth_dev_info_get(port_id, &dev_info); + if (ret != 0) + return ret; + + if (dev_info.pfc_queue_tc_max != 0) { + RTE_ETHDEV_LOG(ERR, + "Ethdev port %u driver does not support port level PFC config\n", + port_id); + return -ENOTSUP; + } + if (pfc_conf->priority > (RTE_ETH_DCB_NUM_USER_PRIORITIES - 1)) { RTE_ETHDEV_LOG(ERR, "Invalid priority, only 0-7 allowed\n"); return -EINVAL; @@ -4022,6 +4035,102 @@ rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, return -ENOTSUP; } +static inline int +validate_rx_pause_config(struct rte_eth_dev_info *dev_info, + struct rte_eth_pfc_queue_conf *pfc_queue_conf) +{ + if ((pfc_queue_conf->mode == RTE_ETH_FC_RX_PAUSE) || + (pfc_queue_conf->mode == RTE_ETH_FC_FULL)) { + if (pfc_queue_conf->rx_pause.tx_qid >= dev_info->nb_tx_queues) { + RTE_ETHDEV_LOG(ERR, "Tx queue not in range for Rx pause" + " (requested: %d configured: %d)\n", + pfc_queue_conf->rx_pause.tx_qid, + dev_info->nb_tx_queues); + return -EINVAL; + } + + if (pfc_queue_conf->rx_pause.tc >= dev_info->pfc_queue_tc_max) { + RTE_ETHDEV_LOG(ERR, "TC not in range for Rx pause" + " (requested: %d max: %d)\n", + pfc_queue_conf->rx_pause.tc, + dev_info->pfc_queue_tc_max); + return -EINVAL; + } + } + + return 0; +} + +static inline int +validate_tx_pause_config(struct rte_eth_dev_info *dev_info, + struct rte_eth_pfc_queue_conf *pfc_queue_conf) +{ + if ((pfc_queue_conf->mode == RTE_ETH_FC_TX_PAUSE) || + (pfc_queue_conf->mode == RTE_ETH_FC_FULL)) { + if (pfc_queue_conf->tx_pause.rx_qid >= dev_info->nb_rx_queues) { + RTE_ETHDEV_LOG(ERR, "Rx queue not in range for Tx pause" + "(requested: %d configured: %d)\n", + pfc_queue_conf->tx_pause.rx_qid, + dev_info->nb_rx_queues); + return -EINVAL; + } + + if (pfc_queue_conf->tx_pause.tc >= dev_info->pfc_queue_tc_max) { + RTE_ETHDEV_LOG(ERR, "TC not in range for Tx pause" + "(requested: %d max: %d)\n", + pfc_queue_conf->tx_pause.tc, + dev_info->pfc_queue_tc_max); + return -EINVAL; + } + } + + return 0; +} + +int +rte_eth_dev_priority_flow_ctrl_queue_set( + uint16_t port_id, struct rte_eth_pfc_queue_conf *pfc_queue_conf) +{ + struct rte_eth_dev_info dev_info; + struct rte_eth_dev *dev; + int ret; + + RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV); + dev = &rte_eth_devices[port_id]; + + if (pfc_queue_conf == NULL) { + RTE_ETHDEV_LOG(ERR, "PFC parameters are NULL for port (%u)\n", + port_id); + return -EINVAL; + } + + ret = rte_eth_dev_info_get(port_id, &dev_info); + if (ret != 0) + return ret; + + if (dev_info.pfc_queue_tc_max == 0) { + RTE_ETHDEV_LOG(ERR, + "Ethdev port %u does not support PFC TC values\n", + port_id); + return -ENOTSUP; + } + + ret = validate_rx_pause_config(&dev_info, pfc_queue_conf); + if (ret != 0) + return ret; + + ret = validate_tx_pause_config(&dev_info, pfc_queue_conf); + if (ret != 0) + return ret; + + + if (*dev->dev_ops->priority_flow_ctrl_queue_set) + return eth_err(port_id, + (*dev->dev_ops->priority_flow_ctrl_queue_set)( + dev, pfc_queue_conf)); + return -ENOTSUP; +} + static int eth_check_reta_mask(struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size) diff --git a/lib/ethdev/rte_ethdev.h b/lib/ethdev/rte_ethdev.h index fa299c8ad7..33e43f6e1d 100644 --- a/lib/ethdev/rte_ethdev.h +++ b/lib/ethdev/rte_ethdev.h @@ -1395,6 +1395,28 @@ struct rte_eth_pfc_conf { uint8_t priority; /**< VLAN User Priority. */ }; +/** + * @warning + * @b EXPERIMENTAL: this API may change, or be removed, without prior notice + * + * A structure used to configure Ethernet priority flow control parameter for + * ethdev queues. + */ +struct rte_eth_pfc_queue_conf { + enum rte_eth_fc_mode mode; /**< Link flow control mode */ + + struct { + uint16_t tx_qid; /**< Tx queue ID */ + uint8_t tc; /**< Traffic class as per PFC (802.1Qbb) spec */ + } rx_pause; /* Valid when (mode == FC_RX_PAUSE || mode == FC_FULL) */ + + struct { + uint16_t pause_time; /**< Pause quota in the Pause frame */ + uint16_t rx_qid; /**< Rx queue ID */ + uint8_t tc; /**< Traffic class as per PFC (802.1Qbb) spec */ + } tx_pause; /* Valid when (mode == FC_TX_PAUSE || mode == FC_FULL) */ +}; + /** * Tunnel type for device-specific classifier configuration. * @see rte_eth_udp_tunnel @@ -1841,8 +1863,30 @@ struct rte_eth_dev_info { * embedded managed interconnect/switch. */ struct rte_eth_switch_info switch_info; - - uint64_t reserved_64s[2]; /**< Reserved for future fields */ + /** + * Maximum supported traffic class as per PFC (802.1Qbb) specification. + * + * Based on device support and use-case need, there are two different + * ways to enable PFC. The first case is the port level PFC + * configuration, in this case, rte_eth_dev_priority_flow_ctrl_set() + * API shall be used to configure the PFC, and PFC frames will be + * generated using based on VLAN TC value. + * The second case is the queue level PFC configuration, in this case, + * Any packet field content can be used to steer the packet to the + * specific queue using rte_flow or RSS and then use + * rte_eth_dev_priority_flow_ctrl_queue_set() to set the TC mapping + * on each queue. Based on congestion selected on the specific queue, + * configured TC shall be used to generate PFC frames. + * + * When set to non zero value, application must use queue level + * PFC configuration via rte_eth_dev_priority_flow_ctrl_queue_set() API + * instead of port level PFC configuration via + * rte_eth_dev_priority_flow_ctrl_set() API to realize + * PFC configuration. + */ + uint8_t pfc_queue_tc_max; + uint8_t reserved_8s[7]; + uint64_t reserved_64s[1]; /**< Reserved for future fields */ void *reserved_ptrs[2]; /**< Reserved for future fields */ }; @@ -4109,6 +4153,9 @@ int rte_eth_dev_flow_ctrl_set(uint16_t port_id, * Configure the Ethernet priority flow control under DCB environment * for Ethernet device. * + * @see struct rte_eth_dev_info::pfc_queue_tc_max priority + * flow control usage models. + * * @param port_id * The port identifier of the Ethernet device. * @param pfc_conf @@ -4119,10 +4166,40 @@ int rte_eth_dev_flow_ctrl_set(uint16_t port_id, * - (-ENODEV) if *port_id* invalid. * - (-EINVAL) if bad parameter * - (-EIO) if flow control setup failure or device is removed. + * */ int rte_eth_dev_priority_flow_ctrl_set(uint16_t port_id, - struct rte_eth_pfc_conf *pfc_conf); + struct rte_eth_pfc_conf *pfc_conf); +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice. + * + * Configure the Ethernet priority flow control for a given queue + * for Ethernet device. + * + * @see struct rte_eth_dev_info::pfc_queue_tc_max priority flow control + * usage models. + * + * @note When an ethdev port switches to PFC mode, the unconfigured + * queues shall be configured by the driver with default values such as + * lower priority value for TC etc. + * + * @param port_id + * The port identifier of the Ethernet device. + * @param pfc_queue_conf + * The pointer to the structure of the priority flow control parameters + * for the queue. + * @return + * - (0) if successful. + * - (-ENOTSUP) if hardware doesn't support priority flow control mode. + * - (-ENODEV) if *port_id* invalid. + * - (-EINVAL) if bad parameter + * - (-EIO) if flow control setup queue failure + */ +__rte_experimental +int rte_eth_dev_priority_flow_ctrl_queue_set(uint16_t port_id, + struct rte_eth_pfc_queue_conf *pfc_queue_conf); /** * Add a MAC address to the set used for filtering incoming packets. * diff --git a/lib/ethdev/version.map b/lib/ethdev/version.map index c2fb0669a4..8f361ec15a 100644 --- a/lib/ethdev/version.map +++ b/lib/ethdev/version.map @@ -256,6 +256,9 @@ EXPERIMENTAL { rte_flow_flex_item_create; rte_flow_flex_item_release; rte_flow_pick_transfer_proxy; + + # added in 22.03 + rte_eth_dev_priority_flow_ctrl_queue_set; }; INTERNAL { From patchwork Thu Jan 13 10:27:18 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob X-Patchwork-Id: 105781 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id D789AA0093; Thu, 13 Jan 2022 11:28:15 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 406D042725; Thu, 13 Jan 2022 11:28:11 +0100 (CET) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 4223640150 for ; Thu, 13 Jan 2022 11:28:09 +0100 (CET) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.16.1.2/8.16.1.2) with ESMTP id 20DABXvl023894; Thu, 13 Jan 2022 02:27:55 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : in-reply-to : references : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=/C9rX5mZPhyoIzfHpXC30Xvbe28Pbi0ndHgKrLtW6z8=; b=ZaT7Ws62uQ6AAcXt9q9I5JTg/Tp8FYXQBQpimC03bcDMP7jhkIUhYdHCcmpNM0E0Gk+2 vtbWIpdhzGQdo1OSFiKlAEd5aeQbB3vYWkH6YherQSbRxgPS9TgVJ1/vha8X+TzYuvM4 940XzNpAwh4g+lswgRmU+RpB8wIc6um3ZiOGYyBpS93p0lIh/TyOi4gN8JN6Ryz3nK1O p5taaKCpf1243bgPYNBPUPr8QryTyPbr3M9A2DzzuL7bDhTrzz3z9YvNxskLJ78TR9rR MUmCryq7Vd55yTz0cNPLsbfq/jG10J7xR4Mf6Rnt1WwfOOrNs+4rJ/poEqoEo9ZxWNZZ mQ== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3djhd4r6pv-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Thu, 13 Jan 2022 02:27:55 -0800 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Thu, 13 Jan 2022 02:27:53 -0800 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Thu, 13 Jan 2022 02:27:53 -0800 Received: from jerin-lab.marvell.com (jerin-lab.marvell.com [10.28.34.14]) by maili.marvell.com (Postfix) with ESMTP id 51FFB3F7043; Thu, 13 Jan 2022 02:27:35 -0800 (PST) From: To: , Xiaoyun Li , Aman Singh , Yuying Zhang CC: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Subject: [dpdk-dev] [PATCH v2 2/2] app/testpmd: add queue based pfc CLI options Date: Thu, 13 Jan 2022 15:57:18 +0530 Message-ID: <20220113102718.3167282-2-jerinj@marvell.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220113102718.3167282-1-jerinj@marvell.com> References: <20220109105851.734687-1-skori@marvell.com> <20220113102718.3167282-1-jerinj@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: cKGYmQh7xA-fG8d768kV8rB30WDu9G0m X-Proofpoint-ORIG-GUID: cKGYmQh7xA-fG8d768kV8rB30WDu9G0m X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.11.62.513 definitions=2022-01-13_02,2022-01-13_01,2021-12-02_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Sunil Kumar Kori Patch adds command line options to configure queue based priority flow control. - Syntax command is given as below: set pfc_queue_ctrl rx \ tx - Example command to configure queue based priority flow control on rx and tx side for port 0, Rx queue 0, Tx queue 0 with pause time 2047 testpmd> set pfc_queue_ctrl 0 rx on 0 0 tx on 0 0 2047 Signed-off-by: Sunil Kumar Kori --- app/test-pmd/cmdline.c | 122 ++++++++++++++++++++ doc/guides/testpmd_app_ug/testpmd_funcs.rst | 22 ++++ 2 files changed, 144 insertions(+) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index e626b1c7d9..19dbcea4f1 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -544,6 +544,11 @@ static void cmd_help_long_parsed(void *parsed_result, " Set the priority flow control parameter on a" " port.\n\n" + "set pfc_queue_ctrl (port_id) rx (on|off) (tx_qid)" + " (tx_tc) tx (on|off) (rx_qid) (rx_tc) (pause_time)\n" + " Set the queue priority flow control parameter on a" + " given Rx and Tx queues of a port.\n\n" + "set stat_qmap (tx|rx) (port_id) (queue_id) (qmapping)\n" " Set statistics mapping (qmapping 0..15) for RX/TX" " queue on port.\n" @@ -7690,6 +7695,122 @@ cmdline_parse_inst_t cmd_priority_flow_control_set = { }, }; +struct cmd_queue_priority_flow_ctrl_set_result { + cmdline_fixed_string_t set; + cmdline_fixed_string_t pfc_queue_ctrl; + portid_t port_id; + cmdline_fixed_string_t rx; + cmdline_fixed_string_t rx_pfc_mode; + uint16_t tx_qid; + uint8_t tx_tc; + cmdline_fixed_string_t tx; + cmdline_fixed_string_t tx_pfc_mode; + uint16_t rx_qid; + uint8_t rx_tc; + uint16_t pause_time; +}; + +static void +cmd_queue_priority_flow_ctrl_set_parsed(void *parsed_result, + __rte_unused struct cmdline *cl, + __rte_unused void *data) +{ + struct cmd_queue_priority_flow_ctrl_set_result *res = parsed_result; + struct rte_eth_pfc_queue_conf pfc_queue_conf; + int rx_fc_enable, tx_fc_enable; + int ret; + + /* + * Rx on/off, flow control is enabled/disabled on RX side. This can + * indicate the RTE_ETH_FC_TX_PAUSE, Transmit pause frame at the Rx + * side. Tx on/off, flow control is enabled/disabled on TX side. This + * can indicate the RTE_ETH_FC_RX_PAUSE, Respond to the pause frame at + * the Tx side. + */ + static enum rte_eth_fc_mode rx_tx_onoff_2_mode[2][2] = { + {RTE_ETH_FC_NONE, RTE_ETH_FC_TX_PAUSE}, + {RTE_ETH_FC_RX_PAUSE, RTE_ETH_FC_FULL} + }; + + memset(&pfc_queue_conf, 0, sizeof(struct rte_eth_pfc_queue_conf)); + rx_fc_enable = (!strncmp(res->rx_pfc_mode, "on", 2)) ? 1 : 0; + tx_fc_enable = (!strncmp(res->tx_pfc_mode, "on", 2)) ? 1 : 0; + pfc_queue_conf.mode = rx_tx_onoff_2_mode[rx_fc_enable][tx_fc_enable]; + pfc_queue_conf.rx_pause.tc = res->tx_tc; + pfc_queue_conf.rx_pause.tx_qid = res->tx_qid; + pfc_queue_conf.tx_pause.tc = res->rx_tc; + pfc_queue_conf.tx_pause.rx_qid = res->rx_qid; + pfc_queue_conf.tx_pause.pause_time = res->pause_time; + + ret = rte_eth_dev_priority_flow_ctrl_queue_set(res->port_id, + &pfc_queue_conf); + if (ret != 0) { + fprintf(stderr, + "bad queue priority flow control parameter, rc = %d\n", + ret); + } +} + +cmdline_parse_token_string_t cmd_q_pfc_set_set = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + set, "set"); +cmdline_parse_token_string_t cmd_q_pfc_set_flow_ctrl = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + pfc_queue_ctrl, "pfc_queue_ctrl"); +cmdline_parse_token_num_t cmd_q_pfc_set_portid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + port_id, RTE_UINT16); +cmdline_parse_token_string_t cmd_q_pfc_set_rx = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx, "rx"); +cmdline_parse_token_string_t cmd_q_pfc_set_rx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_pfc_mode, "on#off"); +cmdline_parse_token_num_t cmd_q_pfc_set_tx_qid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_qid, RTE_UINT16); +cmdline_parse_token_num_t cmd_q_pfc_set_tx_tc = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_tc, RTE_UINT8); +cmdline_parse_token_string_t cmd_q_pfc_set_tx = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx, "tx"); +cmdline_parse_token_string_t cmd_q_pfc_set_tx_mode = + TOKEN_STRING_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + tx_pfc_mode, "on#off"); +cmdline_parse_token_num_t cmd_q_pfc_set_rx_qid = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_qid, RTE_UINT16); +cmdline_parse_token_num_t cmd_q_pfc_set_rx_tc = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + rx_tc, RTE_UINT8); +cmdline_parse_token_num_t cmd_q_pfc_set_pause_time = + TOKEN_NUM_INITIALIZER(struct cmd_queue_priority_flow_ctrl_set_result, + pause_time, RTE_UINT16); + +cmdline_parse_inst_t cmd_queue_priority_flow_control_set = { + .f = cmd_queue_priority_flow_ctrl_set_parsed, + .data = NULL, + .help_str = "set pfc_queue_ctrl rx " + "tx : " + "Configure the Ethernet queue priority flow control", + .tokens = { + (void *)&cmd_q_pfc_set_set, + (void *)&cmd_q_pfc_set_flow_ctrl, + (void *)&cmd_q_pfc_set_portid, + (void *)&cmd_q_pfc_set_rx, + (void *)&cmd_q_pfc_set_rx_mode, + (void *)&cmd_q_pfc_set_tx_qid, + (void *)&cmd_q_pfc_set_tx_tc, + (void *)&cmd_q_pfc_set_tx, + (void *)&cmd_q_pfc_set_tx_mode, + (void *)&cmd_q_pfc_set_rx_qid, + (void *)&cmd_q_pfc_set_rx_tc, + (void *)&cmd_q_pfc_set_pause_time, + NULL, + }, +}; + /* *** RESET CONFIGURATION *** */ struct cmd_reset_result { cmdline_fixed_string_t reset; @@ -17765,6 +17886,7 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg, (cmdline_parse_inst_t *)&cmd_link_flow_control_show, (cmdline_parse_inst_t *)&cmd_priority_flow_control_set, + (cmdline_parse_inst_t *)&cmd_queue_priority_flow_control_set, (cmdline_parse_inst_t *)&cmd_config_dcb, (cmdline_parse_inst_t *)&cmd_read_reg, (cmdline_parse_inst_t *)&cmd_read_reg_bit_field, diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst index 94792d88cc..82333d518e 100644 --- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst +++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst @@ -1561,6 +1561,28 @@ Where: * ``priority`` (0-7): VLAN User Priority. +set pfc_queue_ctrl +~~~~~~~~~~~~~~~~~~ + +Set the priority flow control parameter on a given Rx and Tx queue of a port:: + + testpmd> set pfc_queue_ctrl rx (on|off) \ + tx (on|off) + +Where: + +* ``tx_qid`` (integer): Tx qid for which ``tx_tc`` will be applied and traffic + will be paused when PFC frame is received with ``tx_tc`` enabled. + +* ``tx_tc`` (0-15): TC for which traffic is to be paused for xmit. + +* ``rx_qid`` (integer): Rx qid for which threshold will be applied and PFC + frame will be generated with ``tx_tc`` when exceeds the threshold. + +* ``rx_tc`` (0-15): TC filled in PFC frame for which remote Tx is to be paused. + +* ``pause_time`` (integer): Pause quota filled in the PFC frame. + set stat_qmap ~~~~~~~~~~~~~