drivers/net/bnxt/bnxt_stats.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) Broadcom Limited.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Broadcom Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <inttypes.h>
  35
  36 #include <rte_byteorder.h>
  37
  38 #include "bnxt.h"
  39 #include "bnxt_cpr.h"
  40 #include "bnxt_hwrm.h"
  41 #include "bnxt_rxq.h"
  42 #include "bnxt_stats.h"
  43 #include "bnxt_txq.h"
  44 #include "hsi_struct_def_dpdk.h"
  45
  46 static const struct bnxt_xstats_name_off bnxt_rx_stats_strings[] = {
  47         {"rx_64b_frames", offsetof(struct rx_port_stats,
  48                                 rx_64b_frames)},
  49         {"rx_65b_127b_frames", offsetof(struct rx_port_stats,
  50                                 rx_65b_127b_frames)},
  51         {"rx_128b_255b_frames", offsetof(struct rx_port_stats,
  52                                 rx_128b_255b_frames)},
  53         {"rx_256b_511b_frames", offsetof(struct rx_port_stats,
  54                                 rx_256b_511b_frames)},
  55         {"rx_512b_1023b_frames", offsetof(struct rx_port_stats,
  56                                 rx_512b_1023b_frames)},
  57         {"rx_1024b_1518_frames", offsetof(struct rx_port_stats,
  58                                 rx_1024b_1518_frames)},
  59         {"rx_good_vlan_frames", offsetof(struct rx_port_stats,
  60                                 rx_good_vlan_frames)},
  61         {"rx_1519b_2047b_frames", offsetof(struct rx_port_stats,
  62                                 rx_1519b_2047b_frames)},
  63         {"rx_2048b_4095b_frames", offsetof(struct rx_port_stats,
  64                                 rx_2048b_4095b_frames)},
  65         {"rx_4096b_9216b_frames", offsetof(struct rx_port_stats,
  66                                 rx_4096b_9216b_frames)},
  67         {"rx_9217b_16383b_frames", offsetof(struct rx_port_stats,
  68                                 rx_9217b_16383b_frames)},
  69         {"rx_total_frames", offsetof(struct rx_port_stats,
  70                                 rx_total_frames)},
  71         {"rx_ucast_frames", offsetof(struct rx_port_stats,
  72                                 rx_ucast_frames)},
  73         {"rx_mcast_frames", offsetof(struct rx_port_stats,
  74                                 rx_mcast_frames)},
  75         {"rx_bcast_frames", offsetof(struct rx_port_stats,
  76                                 rx_bcast_frames)},
  77         {"rx_fcs_err_frames", offsetof(struct rx_port_stats,
  78                                 rx_fcs_err_frames)},
  79         {"rx_ctrl_frames", offsetof(struct rx_port_stats,
  80                                 rx_ctrl_frames)},
  81         {"rx_pause_frames", offsetof(struct rx_port_stats,
  82                                 rx_pause_frames)},
  83         {"rx_pfc_frames", offsetof(struct rx_port_stats,
  84                                 rx_pfc_frames)},
  85         {"rx_align_err_frames", offsetof(struct rx_port_stats,
  86                                 rx_align_err_frames)},
  87         {"rx_ovrsz_frames", offsetof(struct rx_port_stats,
  88                                 rx_ovrsz_frames)},
  89         {"rx_jbr_frames", offsetof(struct rx_port_stats,
  90                                 rx_jbr_frames)},
  91         {"rx_mtu_err_frames", offsetof(struct rx_port_stats,
  92                                 rx_mtu_err_frames)},
  93         {"rx_tagged_frames", offsetof(struct rx_port_stats,
  94                                 rx_tagged_frames)},
  95         {"rx_double_tagged_frames", offsetof(struct rx_port_stats,
  96                                 rx_double_tagged_frames)},
  97         {"rx_good_frames", offsetof(struct rx_port_stats,
  98                                 rx_good_frames)},
  99         {"rx_undrsz_frames", offsetof(struct rx_port_stats,
 100                                 rx_undrsz_frames)},
 101         {"rx_eee_lpi_events", offsetof(struct rx_port_stats,
 102                                 rx_eee_lpi_events)},
 103         {"rx_eee_lpi_duration", offsetof(struct rx_port_stats,
 104                                 rx_eee_lpi_duration)},
 105         {"rx_bytes", offsetof(struct rx_port_stats,
 106                                 rx_bytes)},
 107         {"rx_runt_bytes", offsetof(struct rx_port_stats,
 108                                 rx_runt_bytes)},
 109         {"rx_runt_frames", offsetof(struct rx_port_stats,
 110                                 rx_runt_frames)},
 111 };
 112
 113 static const struct bnxt_xstats_name_off bnxt_tx_stats_strings[] = {
 114         {"tx_64b_frames", offsetof(struct tx_port_stats,
 115                                 tx_64b_frames)},
 116         {"tx_65b_127b_frames", offsetof(struct tx_port_stats,
 117                                 tx_65b_127b_frames)},
 118         {"tx_128b_255b_frames", offsetof(struct tx_port_stats,
 119                                 tx_128b_255b_frames)},
 120         {"tx_256b_511b_frames", offsetof(struct tx_port_stats,
 121                                 tx_256b_511b_frames)},
 122         {"tx_512b_1023b_frames", offsetof(struct tx_port_stats,
 123                                 tx_512b_1023b_frames)},
 124         {"tx_1024b_1518_frames", offsetof(struct tx_port_stats,
 125                                 tx_1024b_1518_frames)},
 126         {"tx_good_vlan_frames", offsetof(struct tx_port_stats,
 127                                 tx_good_vlan_frames)},
 128         {"tx_1519b_2047_frames", offsetof(struct tx_port_stats,
 129                                 tx_1519b_2047_frames)},
 130         {"tx_2048b_4095b_frames", offsetof(struct tx_port_stats,
 131                                 tx_2048b_4095b_frames)},
 132         {"tx_4096b_9216b_frames", offsetof(struct tx_port_stats,
 133                                 tx_4096b_9216b_frames)},
 134         {"tx_9217b_16383b_frames", offsetof(struct tx_port_stats,
 135                                 tx_9217b_16383b_frames)},
 136         {"tx_good_frames", offsetof(struct tx_port_stats,
 137                                 tx_good_frames)},
 138         {"tx_total_frames", offsetof(struct tx_port_stats,
 139                                 tx_total_frames)},
 140         {"tx_ucast_frames", offsetof(struct tx_port_stats,
 141                                 tx_ucast_frames)},
 142         {"tx_mcast_frames", offsetof(struct tx_port_stats,
 143                                 tx_mcast_frames)},
 144         {"tx_bcast_frames", offsetof(struct tx_port_stats,
 145                                 tx_bcast_frames)},
 146         {"tx_pause_frames", offsetof(struct tx_port_stats,
 147                                 tx_pause_frames)},
 148         {"tx_pfc_frames", offsetof(struct tx_port_stats,
 149                                 tx_pfc_frames)},
 150         {"tx_jabber_frames", offsetof(struct tx_port_stats,
 151                                 tx_jabber_frames)},
 152         {"tx_fcs_err_frames", offsetof(struct tx_port_stats,
 153                                 tx_fcs_err_frames)},
 154         {"tx_err", offsetof(struct tx_port_stats,
 155                                 tx_err)},
 156         {"tx_fifo_underruns", offsetof(struct tx_port_stats,
 157                                 tx_fifo_underruns)},
 158         {"tx_eee_lpi_events", offsetof(struct tx_port_stats,
 159                                 tx_eee_lpi_events)},
 160         {"tx_eee_lpi_duration", offsetof(struct tx_port_stats,
 161                                 tx_eee_lpi_duration)},
 162         {"tx_total_collisions", offsetof(struct tx_port_stats,
 163                                 tx_total_collisions)},
 164         {"tx_bytes", offsetof(struct tx_port_stats,
 165                                 tx_bytes)},
 166 };
 167
 168 static const struct bnxt_xstats_name_off bnxt_func_stats_strings[] = {
 169         {"tx_ucast_pkts", offsetof(struct hwrm_func_qstats_output,
 170                                 tx_ucast_pkts)},
 171         {"tx_mcast_pkts", offsetof(struct hwrm_func_qstats_output,
 172                                 tx_mcast_pkts)},
 173         {"tx_bcast_pkts", offsetof(struct hwrm_func_qstats_output,
 174                                 tx_bcast_pkts)},
 175         {"tx_err_pkts", offsetof(struct hwrm_func_qstats_output,
 176                                 tx_err_pkts)},
 177         {"tx_drop_pkts", offsetof(struct hwrm_func_qstats_output,
 178                                 tx_drop_pkts)},
 179         {"tx_ucast_bytes", offsetof(struct hwrm_func_qstats_output,
 180                                 tx_ucast_bytes)},
 181         {"tx_mcast_bytes", offsetof(struct hwrm_func_qstats_output,
 182                                 tx_mcast_bytes)},
 183         {"tx_bcast_bytes", offsetof(struct hwrm_func_qstats_output,
 184                                 tx_bcast_bytes)},
 185         {"rx_ucast_pkts", offsetof(struct hwrm_func_qstats_output,
 186                                 rx_ucast_pkts)},
 187         {"rx_mcast_pkts", offsetof(struct hwrm_func_qstats_output,
 188                                 rx_mcast_pkts)},
 189         {"rx_bcast_pkts", offsetof(struct hwrm_func_qstats_output,
 190                                 rx_bcast_pkts)},
 191         {"rx_err_pkts", offsetof(struct hwrm_func_qstats_output,
 192                                 rx_err_pkts)},
 193         {"rx_drop_pkts", offsetof(struct hwrm_func_qstats_output,
 194                                 rx_drop_pkts)},
 195         {"rx_ucast_bytes", offsetof(struct hwrm_func_qstats_output,
 196                                 rx_ucast_bytes)},
 197         {"rx_mcast_bytes", offsetof(struct hwrm_func_qstats_output,
 198                                 rx_mcast_bytes)},
 199         {"rx_bcast_bytes", offsetof(struct hwrm_func_qstats_output,
 200                                 rx_bcast_bytes)},
 201         {"rx_agg_pkts", offsetof(struct hwrm_func_qstats_output,
 202                                 rx_agg_pkts)},
 203         {"rx_agg_bytes", offsetof(struct hwrm_func_qstats_output,
 204                                 rx_agg_bytes)},
 205         {"rx_agg_events", offsetof(struct hwrm_func_qstats_output,
 206                                 rx_agg_events)},
 207         {"rx_agg_aborts", offsetof(struct hwrm_func_qstats_output,
 208                                 rx_agg_aborts)},
 209 };
 210
 211 /*
 212  * Statistics functions
 213  */
 214
 215 void bnxt_free_stats(struct bnxt *bp)
 216 {
 217         int i;
 218
 219         for (i = 0; i < (int)bp->tx_cp_nr_rings; i++) {
 220                 struct bnxt_tx_queue *txq = bp->tx_queues[i];
 221
 222                 bnxt_free_txq_stats(txq);
 223         }
 224         for (i = 0; i < (int)bp->rx_cp_nr_rings; i++) {
 225                 struct bnxt_rx_queue *rxq = bp->rx_queues[i];
 226
 227                 bnxt_free_rxq_stats(rxq);
 228         }
 229 }
 230
 231 int bnxt_stats_get_op(struct rte_eth_dev *eth_dev,
 232                            struct rte_eth_stats *bnxt_stats)
 233 {
 234         int rc = 0;
 235         unsigned int i;
 236         struct bnxt *bp = eth_dev->data->dev_private;
 237
 238         memset(bnxt_stats, 0, sizeof(*bnxt_stats));
 239
 240         for (i = 0; i < bp->rx_cp_nr_rings; i++) {
 241                 struct bnxt_rx_queue *rxq = bp->rx_queues[i];
 242                 struct bnxt_cp_ring_info *cpr = rxq->cp_ring;
 243
 244                 rc = bnxt_hwrm_ctx_qstats(bp, cpr->hw_stats_ctx_id, i,
 245                                      bnxt_stats, 1);
 246                 if (unlikely(rc))
 247                         return rc;
 248         }
 249
 250         for (i = 0; i < bp->tx_cp_nr_rings; i++) {
 251                 struct bnxt_tx_queue *txq = bp->tx_queues[i];
 252                 struct bnxt_cp_ring_info *cpr = txq->cp_ring;
 253
 254                 rc = bnxt_hwrm_ctx_qstats(bp, cpr->hw_stats_ctx_id, i,
 255                                      bnxt_stats, 0);
 256                 if (unlikely(rc))
 257                         return rc;
 258         }
 259         rc = bnxt_hwrm_func_qstats(bp, 0xffff, bnxt_stats);
 260         if (unlikely(rc))
 261                 return rc;
 262         bnxt_stats->rx_nombuf = rte_atomic64_read(&bp->rx_mbuf_alloc_fail);
 263         return rc;
 264 }
 265
 266 void bnxt_stats_reset_op(struct rte_eth_dev *eth_dev)
 267 {
 268         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 269
 270         bnxt_clear_all_hwrm_stat_ctxs(bp);
 271         rte_atomic64_clear(&bp->rx_mbuf_alloc_fail);
 272 }
 273
 274 int bnxt_dev_xstats_get_op(struct rte_eth_dev *eth_dev,
 275                            struct rte_eth_xstat *xstats, unsigned int n)
 276 {
 277         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 278
 279         unsigned int count, i;
 280         uint64_t tx_drop_pkts;
 281
 282         if (!(bp->flags & BNXT_FLAG_PORT_STATS)) {
 283                 RTE_LOG(ERR, PMD, "xstats not supported for VF\n");
 284                 return 0;
 285         }
 286
 287         bnxt_hwrm_port_qstats(bp);
 288         bnxt_hwrm_func_qstats_tx_drop(bp, 0xffff, &tx_drop_pkts);
 289
 290         count = RTE_DIM(bnxt_rx_stats_strings) +
 291                 RTE_DIM(bnxt_tx_stats_strings) + 1; /* For tx_drop_pkts */
 292
 293         if (n < count)
 294                 return count;
 295
 296         count = 0;
 297         for (i = 0; i < RTE_DIM(bnxt_rx_stats_strings); i++) {
 298                 uint64_t *rx_stats = (uint64_t *)bp->hw_rx_port_stats;
 299                 xstats[count].id = count;
 300                 xstats[count].value = rte_le_to_cpu_64(
 301                                 *(uint64_t *)((char *)rx_stats +
 302                                 bnxt_rx_stats_strings[i].offset));
 303                 count++;
 304         }
 305
 306         for (i = 0; i < RTE_DIM(bnxt_tx_stats_strings); i++) {
 307                 uint64_t *tx_stats = (uint64_t *)bp->hw_tx_port_stats;
 308                 xstats[count].id = count;
 309                 xstats[count].value = rte_le_to_cpu_64(
 310                                  *(uint64_t *)((char *)tx_stats +
 311                                 bnxt_tx_stats_strings[i].offset));
 312                 count++;
 313         }
 314
 315         /* The Tx drop pkts aka the Anti spoof coounter */
 316         xstats[count].id = count;
 317         xstats[count].value = rte_le_to_cpu_64(tx_drop_pkts);
 318         count++;
 319
 320         return count;
 321 }
 322
 323 int bnxt_dev_xstats_get_names_op(__rte_unused struct rte_eth_dev *eth_dev,
 324         struct rte_eth_xstat_name *xstats_names,
 325         __rte_unused unsigned int limit)
 326 {
 327         /* Account for the Tx drop pkts aka the Anti spoof counter */
 328         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 329                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 330         unsigned int i, count;
 331
 332         if (xstats_names != NULL) {
 333                 count = 0;
 334
 335                 for (i = 0; i < RTE_DIM(bnxt_rx_stats_strings); i++) {
 336                         snprintf(xstats_names[count].name,
 337                                 sizeof(xstats_names[count].name),
 338                                 "%s",
 339                                 bnxt_rx_stats_strings[i].name);
 340                         count++;
 341                 }
 342
 343                 for (i = 0; i < RTE_DIM(bnxt_tx_stats_strings); i++) {
 344                         snprintf(xstats_names[count].name,
 345                                 sizeof(xstats_names[count].name),
 346                                 "%s",
 347                                 bnxt_tx_stats_strings[i].name);
 348                         count++;
 349                 }
 350
 351                 snprintf(xstats_names[count].name,
 352                                 sizeof(xstats_names[count].name),
 353                                 "%s",
 354                                 bnxt_func_stats_strings[4].name);
 355                 count++;
 356         }
 357         return stat_cnt;
 358 }
 359
 360 void bnxt_dev_xstats_reset_op(struct rte_eth_dev *eth_dev)
 361 {
 362         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 363
 364         if (bp->flags & BNXT_FLAG_PORT_STATS && !BNXT_NPAR_PF(bp))
 365                 bnxt_hwrm_port_clr_stats(bp);
 366
 367         if (BNXT_VF(bp))
 368                 RTE_LOG(ERR, PMD, "Operation not supported on a VF device\n");
 369         if (BNXT_NPAR_PF(bp))
 370                 RTE_LOG(ERR, PMD, "Operation not supported on a MF device\n");
 371         if (!(bp->flags & BNXT_FLAG_PORT_STATS))
 372                 RTE_LOG(ERR, PMD, "Operation not supported\n");
 373 }
 374
 375 int bnxt_dev_xstats_get_by_id_op(struct rte_eth_dev *dev, const uint64_t *ids,
 376                 uint64_t *values, unsigned int limit)
 377 {
 378         /* Account for the Tx drop pkts aka the Anti spoof counter */
 379         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 380                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 381         struct rte_eth_xstat xstats[stat_cnt];
 382         uint64_t values_copy[stat_cnt];
 383         uint16_t i;
 384
 385         if (!ids)
 386                 return bnxt_dev_xstats_get_op(dev, xstats, stat_cnt);
 387
 388         bnxt_dev_xstats_get_by_id_op(dev, NULL, values_copy, stat_cnt);
 389         for (i = 0; i < limit; i++) {
 390                 if (ids[i] >= stat_cnt) {
 391                         RTE_LOG(ERR, PMD, "id value isn't valid");
 392                         return -1;
 393                 }
 394                 values[i] = values_copy[ids[i]];
 395         }
 396         return stat_cnt;
 397 }
 398
 399 int bnxt_dev_xstats_get_names_by_id_op(struct rte_eth_dev *dev,
 400                                 struct rte_eth_xstat_name *xstats_names,
 401                                 const uint64_t *ids, unsigned int limit)
 402 {
 403         /* Account for the Tx drop pkts aka the Anti spoof counter */
 404         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 405                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 406         struct rte_eth_xstat_name xstats_names_copy[stat_cnt];
 407         uint16_t i;
 408
 409         if (!ids)
 410                 return bnxt_dev_xstats_get_names_op(dev, xstats_names,
 411                                                     stat_cnt);
 412         bnxt_dev_xstats_get_names_by_id_op(dev, xstats_names_copy, NULL,
 413                         stat_cnt);
 414
 415         for (i = 0; i < limit; i++) {
 416                 if (ids[i] >= stat_cnt) {
 417                         RTE_LOG(ERR, PMD, "id value isn't valid");
 418                         return -1;
 419                 }
 420                 strcpy(xstats_names[i].name,
 421                                 xstats_names_copy[ids[i]].name);
 422         }
 423         return stat_cnt;
 424 }