net/hns3: fix return value when clearing statistics
[dpdk.git] / drivers / net / hns3 / hns3_stats.c
index b3797ec..d2467a4 100644 (file)
@@ -13,6 +13,7 @@
 #include "hns3_ethdev.h"
 #include "hns3_rxtx.h"
 #include "hns3_logs.h"
+#include "hns3_regs.h"
 
 /* MAC statistics */
 static const struct hns3_xstats_name_offset hns3_mac_strings[] = {
@@ -233,6 +234,32 @@ static const struct hns3_xstats_name_offset hns3_rx_bd_error_strings[] = {
                HNS3_RX_BD_ERROR_STATS_FIELD_OFFSET(ol4_csum_erros)}
 };
 
+/* The statistic of the Tx errors */
+static const struct hns3_xstats_name_offset hns3_tx_errors_strings[] = {
+       {"TX_OVER_LENGTH_PKT_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(over_length_pkt_cnt)},
+       {"TX_EXCEED_LIMITED_BD_PKT_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(exceed_limit_bd_pkt_cnt)},
+       {"TX_EXCEED_LIMITED_BD_PKT_REASSEMBLE_FAIL_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(exceed_limit_bd_reassem_fail)},
+       {"TX_UNSUPPORTED_TUNNEL_PKT_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(unsupported_tunnel_pkt_cnt)},
+       {"TX_QUEUE_FULL_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(queue_full_cnt)},
+       {"TX_SHORT_PKT_PAD_FAIL_CNT",
+               HNS3_TX_ERROR_STATS_FIELD_OFFSET(pkt_padding_fail_cnt)}
+};
+
+/* The statistic of rx queue */
+static const struct hns3_xstats_name_offset hns3_rx_queue_strings[] = {
+       {"RX_QUEUE_FBD", HNS3_RING_RX_FBDNUM_REG}
+};
+
+/* The statistic of tx queue */
+static const struct hns3_xstats_name_offset hns3_tx_queue_strings[] = {
+       {"TX_QUEUE_FBD", HNS3_RING_TX_FBDNUM_REG}
+};
+
 #define HNS3_NUM_MAC_STATS (sizeof(hns3_mac_strings) / \
        sizeof(hns3_mac_strings[0]))
 
@@ -245,6 +272,15 @@ static const struct hns3_xstats_name_offset hns3_rx_bd_error_strings[] = {
 #define HNS3_NUM_RX_BD_ERROR_XSTATS (sizeof(hns3_rx_bd_error_strings) / \
        sizeof(hns3_rx_bd_error_strings[0]))
 
+#define HNS3_NUM_TX_ERRORS_XSTATS (sizeof(hns3_tx_errors_strings) / \
+       sizeof(hns3_tx_errors_strings[0]))
+
+#define HNS3_NUM_RX_QUEUE_STATS (sizeof(hns3_rx_queue_strings) / \
+       sizeof(hns3_rx_queue_strings[0]))
+
+#define HNS3_NUM_TX_QUEUE_STATS (sizeof(hns3_tx_queue_strings) / \
+       sizeof(hns3_tx_queue_strings[0]))
+
 #define HNS3_FIX_NUM_STATS (HNS3_NUM_MAC_STATS + HNS3_NUM_ERROR_INT_XSTATS + \
                            HNS3_NUM_RESET_XSTATS)
 
@@ -474,6 +510,7 @@ hns3_stats_reset(struct rte_eth_dev *eth_dev)
        struct hns3_tqp_stats *stats = &hw->tqp_stats;
        struct hns3_cmd_desc desc_reset;
        struct hns3_rx_queue *rxq;
+       struct hns3_tx_queue *txq;
        uint16_t i;
        int ret;
 
@@ -490,6 +527,7 @@ hns3_stats_reset(struct rte_eth_dev *eth_dev)
                if (ret) {
                        hns3_err(hw, "Failed to reset RX No.%d queue stat: %d",
                                 i, ret);
+                       return ret;
                }
 
                hns3_cmd_setup_basic_desc(&desc_reset, HNS3_OPC_QUERY_TX_STATUS,
@@ -500,10 +538,11 @@ hns3_stats_reset(struct rte_eth_dev *eth_dev)
                if (ret) {
                        hns3_err(hw, "Failed to reset TX No.%d queue stat: %d",
                                 i, ret);
+                       return ret;
                }
        }
 
-       /* Clear Rx BD and Tx error stats */
+       /* Clear the Rx BD errors stats */
        for (i = 0; i != eth_dev->data->nb_rx_queues; ++i) {
                rxq = eth_dev->data->rx_queues[i];
                if (rxq) {
@@ -516,12 +555,25 @@ hns3_stats_reset(struct rte_eth_dev *eth_dev)
                }
        }
 
+       /* Clear the Tx errors stats */
+       for (i = 0; i != eth_dev->data->nb_tx_queues; ++i) {
+               txq = eth_dev->data->tx_queues[i];
+               if (txq) {
+                       txq->over_length_pkt_cnt = 0;
+                       txq->exceed_limit_bd_pkt_cnt = 0;
+                       txq->exceed_limit_bd_reassem_fail = 0;
+                       txq->unsupported_tunnel_pkt_cnt = 0;
+                       txq->queue_full_cnt = 0;
+                       txq->pkt_padding_fail_cnt = 0;
+               }
+       }
+
        memset(stats, 0, sizeof(struct hns3_tqp_stats));
 
        return 0;
 }
 
-static void
+static int
 hns3_mac_stats_reset(__rte_unused struct rte_eth_dev *dev)
 {
        struct hns3_adapter *hns = dev->data->dev_private;
@@ -530,10 +582,14 @@ hns3_mac_stats_reset(__rte_unused struct rte_eth_dev *dev)
        int ret;
 
        ret = hns3_query_update_mac_stats(dev);
-       if (ret)
+       if (ret) {
                hns3_err(hw, "Clear Mac stats fail : %d", ret);
+               return ret;
+       }
 
        memset(mac_stats, 0, sizeof(struct hns3_mac_stats));
+
+       return 0;
 }
 
 /* This function calculates the number of xstats based on the current config */
@@ -541,13 +597,52 @@ static int
 hns3_xstats_calc_num(struct rte_eth_dev *dev)
 {
        struct hns3_adapter *hns = dev->data->dev_private;
+       int bderr_stats = dev->data->nb_rx_queues * HNS3_NUM_RX_BD_ERROR_XSTATS;
+       int tx_err_stats = dev->data->nb_tx_queues * HNS3_NUM_TX_ERRORS_XSTATS;
+       int rx_queue_stats = dev->data->nb_rx_queues * HNS3_NUM_RX_QUEUE_STATS;
+       int tx_queue_stats = dev->data->nb_tx_queues * HNS3_NUM_TX_QUEUE_STATS;
 
        if (hns->is_vf)
-               return dev->data->nb_rx_queues * HNS3_NUM_RX_BD_ERROR_XSTATS +
-                      HNS3_NUM_RESET_XSTATS;
+               return bderr_stats + tx_err_stats + rx_queue_stats +
+                      tx_queue_stats + HNS3_NUM_RESET_XSTATS;
        else
-               return dev->data->nb_rx_queues * HNS3_NUM_RX_BD_ERROR_XSTATS +
-                      HNS3_FIX_NUM_STATS;
+               return bderr_stats + tx_err_stats + rx_queue_stats +
+                      tx_queue_stats + HNS3_FIX_NUM_STATS;
+}
+
+static void
+hns3_get_queue_stats(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
+                    int *count)
+{
+       struct hns3_adapter *hns = dev->data->dev_private;
+       struct hns3_hw *hw = &hns->hw;
+       uint32_t reg_offset;
+       uint16_t i, j;
+
+       /* Get rx queue stats */
+       for (j = 0; j < dev->data->nb_rx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_RX_QUEUE_STATS; i++) {
+                       reg_offset = HNS3_TQP_REG_OFFSET +
+                                       HNS3_TQP_REG_SIZE * j;
+                       xstats[*count].value = hns3_read_dev(hw,
+                               reg_offset + hns3_rx_queue_strings[i].offset);
+                       xstats[*count].id = *count;
+                       (*count)++;
+               }
+       }
+
+       /* Get tx queue stats */
+       for (j = 0; j < dev->data->nb_tx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_TX_QUEUE_STATS; i++) {
+                       reg_offset = HNS3_TQP_REG_OFFSET +
+                                       HNS3_TQP_REG_SIZE * j;
+                       xstats[*count].value = hns3_read_dev(hw,
+                               reg_offset + hns3_tx_queue_strings[i].offset);
+                       xstats[*count].id = *count;
+                       (*count)++;
+               }
+       }
+
 }
 
 /*
@@ -573,6 +668,7 @@ hns3_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
        struct hns3_mac_stats *mac_stats = &hw->mac_stats;
        struct hns3_reset_stats *reset_stats = &hw->reset.stats;
        struct hns3_rx_queue *rxq;
+       struct hns3_tx_queue *txq;
        uint16_t i, j;
        char *addr;
        int count;
@@ -621,7 +717,7 @@ hns3_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
        }
 
        /* Get the Rx BD errors stats */
-       for (j = 0; j != dev->data->nb_rx_queues; ++j) {
+       for (j = 0; j < dev->data->nb_rx_queues; j++) {
                for (i = 0; i < HNS3_NUM_RX_BD_ERROR_XSTATS; i++) {
                        rxq = dev->data->rx_queues[j];
                        addr = (char *)rxq + hns3_rx_bd_error_strings[i].offset;
@@ -631,6 +727,18 @@ hns3_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
                }
        }
 
+       /* Get the Tx errors stats */
+       for (j = 0; j < dev->data->nb_tx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_TX_ERRORS_XSTATS; i++) {
+                       txq = dev->data->tx_queues[j];
+                       addr = (char *)txq + hns3_tx_errors_strings[i].offset;
+                       xstats[count].value = *(uint64_t *)addr;
+                       xstats[count].id = count;
+                       count++;
+               }
+       }
+
+       hns3_get_queue_stats(dev, xstats, &count);
        return count;
 }
 
@@ -659,7 +767,7 @@ hns3_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
  *     is the number of entries filled in the stats table.
  */
 int
-hns3_dev_xstats_get_names(__rte_unused struct rte_eth_dev *dev,
+hns3_dev_xstats_get_names(struct rte_eth_dev *dev,
                          struct rte_eth_xstat_name *xstats_names,
                          __rte_unused unsigned int size)
 {
@@ -705,6 +813,34 @@ hns3_dev_xstats_get_names(__rte_unused struct rte_eth_dev *dev,
                }
        }
 
+       for (j = 0; j < dev->data->nb_tx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_TX_ERRORS_XSTATS; i++) {
+                       snprintf(xstats_names[count].name,
+                                sizeof(xstats_names[count].name),
+                                "tx_q%u%s", j,
+                                hns3_tx_errors_strings[i].name);
+                       count++;
+               }
+       }
+
+       for (j = 0; j < dev->data->nb_rx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_RX_QUEUE_STATS; i++) {
+                       snprintf(xstats_names[count].name,
+                                sizeof(xstats_names[count].name),
+                                "rx_q%u%s", j, hns3_rx_queue_strings[i].name);
+                       count++;
+               }
+       }
+
+       for (j = 0; j < dev->data->nb_tx_queues; j++) {
+               for (i = 0; i < HNS3_NUM_TX_QUEUE_STATS; i++) {
+                       snprintf(xstats_names[count].name,
+                                sizeof(xstats_names[count].name),
+                                "tx_q%u%s", j, hns3_tx_queue_strings[i].name);
+                       count++;
+               }
+       }
+
        return count;
 }
 
@@ -735,18 +871,13 @@ int
 hns3_dev_xstats_get_by_id(struct rte_eth_dev *dev, const uint64_t *ids,
                          uint64_t *values, uint32_t size)
 {
+       const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
        struct hns3_adapter *hns = dev->data->dev_private;
-       struct hns3_pf *pf = &hns->pf;
+       struct rte_eth_xstat *values_copy;
        struct hns3_hw *hw = &hns->hw;
-       struct hns3_mac_stats *mac_stats = &hw->mac_stats;
-       struct hns3_reset_stats *reset_stats = &hw->reset.stats;
-       struct hns3_rx_queue *rxq;
-       const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
-       uint64_t *values_copy;
+       uint32_t count_value;
        uint64_t len;
-       uint32_t count = 0;
-       uint16_t i, j;
-       char *addr;
+       uint32_t i;
        int ret;
 
        if (ids == NULL || size < cnt_stats)
@@ -759,7 +890,7 @@ hns3_dev_xstats_get_by_id(struct rte_eth_dev *dev, const uint64_t *ids,
                return ret;
        }
 
-       len = cnt_stats * HNS3_VALUES_BYTES;
+       len = cnt_stats * sizeof(struct rte_eth_xstat);
        values_copy = rte_zmalloc("hns3_xstats_values", len, 0);
        if (values_copy == NULL) {
                hns3_err(hw, "Failed to allocate %" PRIx64 " bytes needed "
@@ -767,36 +898,10 @@ hns3_dev_xstats_get_by_id(struct rte_eth_dev *dev, const uint64_t *ids,
                return -ENOMEM;
        }
 
-       if (!hns->is_vf) {
-               /* Get MAC name from hw->hw_xstats.mac_stats */
-               for (i = 0; i < HNS3_NUM_MAC_STATS; i++) {
-                       addr = (char *)mac_stats + hns3_mac_strings[i].offset;
-                       values_copy[count] = *(uint64_t *)addr;
-                       count++;
-               }
-
-               for (i = 0; i < HNS3_NUM_ERROR_INT_XSTATS; i++) {
-                       addr = (char *)&pf->abn_int_stats +
-                              hns3_error_int_stats_strings[i].offset;
-                       values_copy[count] = *(uint64_t *)addr;
-                       count++;
-               }
-       }
-
-       for (i = 0; i < HNS3_NUM_RESET_XSTATS; i++) {
-               addr = (char *)reset_stats +
-                      hns3_reset_stats_strings[i].offset;
-               values_copy[count] = *(uint64_t *)addr;
-               count++;
-       }
-
-       for (j = 0; j != dev->data->nb_rx_queues; ++j) {
-               for (i = 0; i < HNS3_NUM_RX_BD_ERROR_XSTATS; i++) {
-                       rxq = dev->data->rx_queues[j];
-                       addr = (char *)rxq + hns3_rx_bd_error_strings[i].offset;
-                       values_copy[count] = *(uint64_t *)addr;
-                       count++;
-               }
+       count_value = hns3_dev_xstats_get(dev, values_copy, cnt_stats);
+       if (count_value != cnt_stats) {
+               rte_free(values_copy);
+               return -EINVAL;
        }
 
        for (i = 0; i < size; i++) {
@@ -806,7 +911,8 @@ hns3_dev_xstats_get_by_id(struct rte_eth_dev *dev, const uint64_t *ids,
                        rte_free(values_copy);
                        return -EINVAL;
                }
-               memcpy(&values[i], &values_copy[ids[i]], sizeof(values[i]));
+               memcpy(&values[i], &values_copy[ids[i]].value,
+                       sizeof(values[i]));
        }
 
        rte_free(values_copy);
@@ -839,67 +945,38 @@ hns3_dev_xstats_get_names_by_id(struct rte_eth_dev *dev,
                                struct rte_eth_xstat_name *xstats_names,
                                const uint64_t *ids, uint32_t size)
 {
+       const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
        struct hns3_adapter *hns = dev->data->dev_private;
-       struct rte_eth_xstat_name *xstats_names_copy;
+       struct rte_eth_xstat_name *names_copy;
        struct hns3_hw *hw = &hns->hw;
-       const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
-       uint16_t count_name = 0;
-       uint16_t i, j;
        uint64_t len;
+       uint32_t i;
 
        if (ids == NULL || xstats_names == NULL)
                return cnt_stats;
 
        len = cnt_stats * sizeof(struct rte_eth_xstat_name);
-       xstats_names_copy = rte_zmalloc("hns3_xstats_names", len, 0);
-       if (xstats_names_copy == NULL) {
+       names_copy = rte_zmalloc("hns3_xstats_names", len, 0);
+       if (names_copy == NULL) {
                hns3_err(hw, "Failed to allocate %" PRIx64 " bytes needed "
                             "to store statistics names", len);
                return -ENOMEM;
        }
 
-       if (!hns->is_vf) {
-               for (i = 0; i < HNS3_NUM_MAC_STATS; i++) {
-                       snprintf(xstats_names_copy[count_name].name,
-                                sizeof(xstats_names_copy[count_name].name),
-                                "%s", hns3_mac_strings[i].name);
-                       count_name++;
-               }
-               for (i = 0; i < HNS3_NUM_ERROR_INT_XSTATS; i++) {
-                       snprintf(xstats_names_copy[count_name].name,
-                                sizeof(xstats_names_copy[count_name].name),
-                                "%s", hns3_error_int_stats_strings[i].name);
-                       count_name++;
-               }
-       }
-       for (i = 0; i < HNS3_NUM_RESET_XSTATS; i++) {
-               snprintf(xstats_names_copy[count_name].name,
-                        sizeof(xstats_names_copy[count_name].name),
-                        "%s", hns3_reset_stats_strings[i].name);
-               count_name++;
-       }
-       for (j = 0; j != dev->data->nb_rx_queues; ++j) {
-               for (i = 0; i < HNS3_NUM_RX_BD_ERROR_XSTATS; i++) {
-                       snprintf(xstats_names_copy[count_name].name,
-                                sizeof(xstats_names_copy[count_name].name),
-                                "rx_q%u%s", j,
-                                hns3_rx_bd_error_strings[i].name);
-                       count_name++;
-               }
-       }
+       (void)hns3_dev_xstats_get_names(dev, names_copy, cnt_stats);
 
        for (i = 0; i < size; i++) {
                if (ids[i] >= cnt_stats) {
                        hns3_err(hw, "ids[%d] (%" PRIx64 ") is invalid, "
                                     "should < %u", i, ids[i], cnt_stats);
-                       rte_free(xstats_names_copy);
+                       rte_free(names_copy);
                        return -EINVAL;
                }
                snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
-                        "%s", xstats_names_copy[ids[i]].name);
+                        "%s", names_copy[ids[i]].name);
        }
 
-       rte_free(xstats_names_copy);
+       rte_free(names_copy);
        return size;
 }
 
@@ -908,9 +985,13 @@ hns3_dev_xstats_reset(struct rte_eth_dev *dev)
 {
        struct hns3_adapter *hns = dev->data->dev_private;
        struct hns3_pf *pf = &hns->pf;
+       int ret;
 
        /* Clear tqp stats */
-       (void)hns3_stats_reset(dev);
+       ret = hns3_stats_reset(dev);
+       if (ret)
+               return ret;
+
        /* Clear reset stats */
        memset(&hns->hw.reset.stats, 0, sizeof(struct hns3_reset_stats));
 
@@ -918,7 +999,10 @@ hns3_dev_xstats_reset(struct rte_eth_dev *dev)
                return 0;
 
        /* HW registers are cleared on read */
-       hns3_mac_stats_reset(dev);
+       ret = hns3_mac_stats_reset(dev);
+       if (ret)
+               return ret;
+
        /* Clear error stats */
        memset(&pf->abn_int_stats, 0, sizeof(struct hns3_err_msix_intr_stats));