From patchwork Fri Feb 11 04:49:26 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "humin (Q)" X-Patchwork-Id: 107340 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 14D07A00BE; Fri, 11 Feb 2022 05:49:58 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 8477E42707; Fri, 11 Feb 2022 05:49:38 +0100 (CET) Received: from szxga01-in.huawei.com (szxga01-in.huawei.com [45.249.212.187]) by mails.dpdk.org (Postfix) with ESMTP id D314F426EA for ; Fri, 11 Feb 2022 05:49:35 +0100 (CET) Received: from dggeme756-chm.china.huawei.com (unknown [172.30.72.57]) by szxga01-in.huawei.com (SkyGuard) with ESMTP id 4Jw1N00CyBzccss for ; Fri, 11 Feb 2022 12:48:32 +0800 (CST) Received: from localhost.localdomain (10.69.192.56) by dggeme756-chm.china.huawei.com (10.3.19.102) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.2308.21; Fri, 11 Feb 2022 12:49:33 +0800 From: "Min Hu (Connor)" To: CC: "Min Hu (Connor)" , Yisen Zhuang , Lijun Ou Subject: [PATCH 5/9] net/hns3: dump queue info Date: Fri, 11 Feb 2022 12:49:26 +0800 Message-ID: <20220211044930.2449-6-humin29@huawei.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20220211044930.2449-1-humin29@huawei.com> References: <20220211044930.2449-1-humin29@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.69.192.56] X-ClientProxiedBy: dggems702-chm.china.huawei.com (10.3.19.179) To dggeme756-chm.china.huawei.com (10.3.19.102) X-CFilter-Loop: Reflected 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 This patch dumps Rx/Tx queue info, such as queue numbers, queue enable state for debug. Signed-off-by: Min Hu (Connor) --- drivers/net/hns3/hns3_ethdev_dump.c | 224 ++++++++++++++++++++++++++++ 1 file changed, 224 insertions(+) diff --git a/drivers/net/hns3/hns3_ethdev_dump.c b/drivers/net/hns3/hns3_ethdev_dump.c index 6ceeb5a349..f9647e6007 100644 --- a/drivers/net/hns3/hns3_ethdev_dump.c +++ b/drivers/net/hns3/hns3_ethdev_dump.c @@ -138,6 +138,229 @@ get_device_basic_info(FILE *file, struct rte_eth_dev *dev) dev->data->dev_conf.intr_conf.rxq); } +/* + * Note: caller must make sure queue_id < nb_queues + * nb_queues = RTE_MAX(eth_dev->data->nb_rx_queues, + * eth_dev->data->nb_tx_queues) + */ +static struct hns3_rx_queue * +get_rx_queue(struct rte_eth_dev *dev, unsigned int queue_id) +{ + struct hns3_adapter *hns = dev->data->dev_private; + struct hns3_hw *hw = &hns->hw; + unsigned int offset; + void **rx_queues; + + if (queue_id < dev->data->nb_rx_queues) { + rx_queues = dev->data->rx_queues; + offset = queue_id; + } else { + /* + * For kunpeng930, fake queue is not exist. But since the queues + * are usually accessd in pairs, this branch may still exist. + */ + if (hns3_dev_get_support(hw, INDEP_TXRX)) + return NULL; + + rx_queues = hw->fkq_data.rx_queues; + offset = queue_id - dev->data->nb_rx_queues; + } + + if (rx_queues != NULL && rx_queues[offset] != NULL) + return rx_queues[offset]; + + hns3_err(hw, "Detect rx_queues is NULL!\n"); + return NULL; +} + +/* + * Note: caller must make sure queue_id < nb_queues + * nb_queues = RTE_MAX(eth_dev->data->nb_rx_queues, + * eth_dev->data->nb_tx_queues) + */ +static struct hns3_tx_queue * +get_tx_queue(struct rte_eth_dev *dev, unsigned int queue_id) +{ + struct hns3_adapter *hns = dev->data->dev_private; + struct hns3_hw *hw = &hns->hw; + unsigned int offset; + void **tx_queues; + + if (queue_id < dev->data->nb_tx_queues) { + tx_queues = dev->data->tx_queues; + offset = queue_id; + } else { + /* + * For kunpeng930, fake queue is not exist. But since the queues + * are usually accessd in pairs, this branch may still exist. + */ + if (hns3_dev_get_support(hw, INDEP_TXRX)) + return NULL; + tx_queues = hw->fkq_data.tx_queues; + offset = queue_id - dev->data->nb_tx_queues; + } + + if (tx_queues != NULL && tx_queues[offset] != NULL) + return tx_queues[offset]; + + hns3_err(hw, "Detect tx_queues is NULL!\n"); + return NULL; +} + +static void +get_rxtx_fake_queue_info(FILE *file, struct rte_eth_dev *dev) +{ + struct hns3_adapter *hns = dev->data->dev_private; + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(hns); + struct hns3_rx_queue *rxq; + struct hns3_tx_queue *txq; + unsigned int queue_id; + + if (dev->data->nb_rx_queues != dev->data->nb_tx_queues && + !hns3_dev_get_support(hw, INDEP_TXRX)) { + queue_id = RTE_MIN(dev->data->nb_rx_queues, + dev->data->nb_tx_queues); + rxq = get_rx_queue(dev, queue_id); + if (rxq == NULL) + return; + txq = get_tx_queue(dev, queue_id); + if (txq == NULL) + return; + fprintf(file, + "\t -- first fake_queue rxtx info:\n" + "\t rx: port=%u nb_desc=%u free_thresh=%u\n" + "\t tx: port=%u nb_desc=%u\n", + rxq->port_id, rxq->nb_rx_desc, rxq->rx_free_thresh, + txq->port_id, txq->nb_tx_desc); + } +} + +static void +get_queue_enable_state(struct hns3_hw *hw, uint32_t *queue_state, + uint32_t nb_queues, bool is_rxq) +{ +#define STATE_SIZE (sizeof(*queue_state) * CHAR_BIT) + uint32_t queue_en_reg; + uint32_t reg_offset; + uint32_t state; + uint32_t i; + + queue_en_reg = is_rxq ? HNS3_RING_RX_EN_REG : HNS3_RING_TX_EN_REG; + for (i = 0; i < nb_queues; i++) { + reg_offset = hns3_get_tqp_reg_offset(i); + state = hns3_read_dev(hw, reg_offset + HNS3_RING_EN_REG); + if (hns3_dev_get_support(hw, INDEP_TXRX)) + state = state && hns3_read_dev(hw, reg_offset + + queue_en_reg); + hns3_set_bit(queue_state[i / STATE_SIZE], + i % STATE_SIZE, state); + } +} + +static void +print_queue_state_perline(FILE *file, const uint32_t *queue_state, + uint32_t nb_queues, uint32_t line_num) +{ +#define NUM_QUEUE_PER_LINE (sizeof(*queue_state) * CHAR_BIT) + uint32_t qid = line_num * NUM_QUEUE_PER_LINE; + uint32_t j; + + for (j = 0; j < NUM_QUEUE_PER_LINE; j++) { + fprintf(file, "%1lx", hns3_get_bit(queue_state[line_num], j)); + + if (qid % CHAR_BIT == CHAR_BIT - 1) { + fprintf(file, "%s", + j == NUM_QUEUE_PER_LINE - 1 ? "\n" : ":"); + } + qid++; + if (qid >= nb_queues) { + fprintf(file, "\n"); + break; + } + } +} + +static void +display_queue_enable_state(FILE *file, const uint32_t *queue_state, + uint32_t nb_queues, bool is_rxq) +{ +#define NUM_QUEUE_PER_LINE (sizeof(*queue_state) * CHAR_BIT) + uint32_t i; + + if (nb_queues == 0) { + fprintf(file, "\t %s queue number is 0\n", + is_rxq ? "Rx" : "Tx"); + return; + } + + fprintf(file, "\t %s queue id | enable state bitMap\n", + is_rxq ? "rx" : "tx"); + + for (i = 0; i < (nb_queues - 1) / NUM_QUEUE_PER_LINE + 1; i++) { + uint32_t line_end = (i + 1) * NUM_QUEUE_PER_LINE - 1; + uint32_t line_start = i * NUM_QUEUE_PER_LINE; + fprintf(file, "\t %04u - %04u | ", line_start, + nb_queues - 1 > line_end ? line_end : nb_queues - 1); + + + print_queue_state_perline(file, queue_state, nb_queues, i); + } +} + +static void +get_rxtx_queue_enable_state(FILE *file, struct rte_eth_dev *dev) +{ +#define MAX_TQP_NUM 1280 +#define QUEUE_BITMAP_SIZE (MAX_TQP_NUM / 32) + struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private); + uint32_t rx_queue_state[QUEUE_BITMAP_SIZE] = {0}; + uint32_t tx_queue_state[QUEUE_BITMAP_SIZE] = {0}; + uint32_t nb_rx_queues; + uint32_t nb_tx_queues; + + nb_rx_queues = dev->data->nb_rx_queues; + nb_tx_queues = dev->data->nb_tx_queues; + + fprintf(file, "\t -- enable state:\n"); + get_queue_enable_state(hw, rx_queue_state, nb_rx_queues, true); + display_queue_enable_state(file, rx_queue_state, nb_rx_queues, + true); + + get_queue_enable_state(hw, tx_queue_state, nb_tx_queues, false); + display_queue_enable_state(file, tx_queue_state, nb_tx_queues, + false); +} + +static void +get_rxtx_queue_info(FILE *file, struct rte_eth_dev *dev) +{ + struct hns3_rx_queue *rxq; + struct hns3_tx_queue *txq; + unsigned int queue_id = 0; + + rxq = get_rx_queue(dev, queue_id); + if (rxq == NULL) + return; + txq = get_tx_queue(dev, queue_id); + if (txq == NULL) + return; + fprintf(file, " - Rx/Tx Queue Info:\n"); + fprintf(file, + "\t -- nb_rx_queues=%u nb_tx_queues=%u, " + "first queue rxtx info:\n" + "\t rx: port=%u nb_desc=%u free_thresh=%u\n" + "\t tx: port=%u nb_desc=%u\n" + "\t -- tx push: %s\n", + dev->data->nb_rx_queues, + dev->data->nb_tx_queues, + rxq->port_id, rxq->nb_rx_desc, rxq->rx_free_thresh, + txq->port_id, txq->nb_tx_desc, + txq->tx_push_enable ? "enabled" : "disabled"); + + get_rxtx_fake_queue_info(file, dev); + get_rxtx_queue_enable_state(file, dev); +} + int hns3_eth_dev_priv_dump(struct rte_eth_dev *dev, FILE *file) { @@ -152,6 +375,7 @@ hns3_eth_dev_priv_dump(struct rte_eth_dev *dev, FILE *file) return 0; get_dev_mac_info(file, hns); + get_rxtx_queue_info(file, dev); return 0; }