drivers/net/mlx5/mlx5_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2015 6WIND S.A.
   3  * Copyright 2015 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <inttypes.h>
   7 #include <stdint.h>
   8 #include <stdio.h>
   9 #include <unistd.h>
  10
  11 #include <rte_ethdev_driver.h>
  12 #include <rte_common.h>
  13 #include <rte_malloc.h>
  14
  15 #include <mlx5_common.h>
  16
  17 #include "mlx5_defs.h"
  18 #include "mlx5.h"
  19 #include "mlx5_rxtx.h"
  20
  21 /**
  22  * DPDK callback to get extended device statistics.
  23  *
  24  * @param dev
  25  *   Pointer to Ethernet device.
  26  * @param[out] stats
  27  *   Pointer to rte extended stats table.
  28  * @param n
  29  *   The size of the stats table.
  30  *
  31  * @return
  32  *   Number of extended stats on success and stats is filled,
  33  *   negative on error and rte_errno is set.
  34  */
  35 int
  36 mlx5_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *stats,
  37                 unsigned int n)
  38 {
  39         struct mlx5_priv *priv = dev->data->dev_private;
  40         unsigned int i;
  41         uint64_t counters[n];
  42         struct mlx5_xstats_ctrl *xstats_ctrl = &priv->xstats_ctrl;
  43         uint16_t mlx5_stats_n = xstats_ctrl->mlx5_stats_n;
  44
  45         if (n >= mlx5_stats_n && stats) {
  46                 int stats_n;
  47                 int ret;
  48
  49                 stats_n = mlx5_os_get_stats_n(dev);
  50                 if (stats_n < 0)
  51                         return stats_n;
  52                 if (xstats_ctrl->stats_n != stats_n)
  53                         mlx5_os_stats_init(dev);
  54                 ret = mlx5_os_read_dev_counters(dev, counters);
  55                 if (ret)
  56                         return ret;
  57                 for (i = 0; i != mlx5_stats_n; ++i) {
  58                         stats[i].id = i;
  59                         if (xstats_ctrl->info[i].dev) {
  60                                 uint64_t wrap_n;
  61                                 uint64_t hw_stat = xstats_ctrl->hw_stats[i];
  62
  63                                 stats[i].value = (counters[i] -
  64                                                   xstats_ctrl->base[i]) &
  65                                                   (uint64_t)UINT32_MAX;
  66                                 wrap_n = hw_stat >> 32;
  67                                 if (stats[i].value <
  68                                             (hw_stat & (uint64_t)UINT32_MAX))
  69                                         wrap_n++;
  70                                 stats[i].value |= (wrap_n) << 32;
  71                                 xstats_ctrl->hw_stats[i] = stats[i].value;
  72                         } else {
  73                                 stats[i].value =
  74                                         (counters[i] - xstats_ctrl->base[i]);
  75                         }
  76                 }
  77         }
  78         mlx5_stats_n = mlx5_txpp_xstats_get(dev, stats, n, mlx5_stats_n);
  79         return mlx5_stats_n;
  80 }
  81
  82 /**
  83  * DPDK callback to get device statistics.
  84  *
  85  * @param dev
  86  *   Pointer to Ethernet device structure.
  87  * @param[out] stats
  88  *   Stats structure output buffer.
  89  *
  90  * @return
  91  *   0 on success and stats is filled, negative errno value otherwise and
  92  *   rte_errno is set.
  93  */
  94 int
  95 mlx5_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
  96 {
  97         struct mlx5_priv *priv = dev->data->dev_private;
  98         struct mlx5_stats_ctrl *stats_ctrl = &priv->stats_ctrl;
  99         struct rte_eth_stats tmp;
 100         unsigned int i;
 101         unsigned int idx;
 102         uint64_t wrap_n;
 103         int ret;
 104
 105         memset(&tmp, 0, sizeof(tmp));
 106         /* Add software counters. */
 107         for (i = 0; (i != priv->rxqs_n); ++i) {
 108                 struct mlx5_rxq_data *rxq = (*priv->rxqs)[i];
 109
 110                 if (rxq == NULL)
 111                         continue;
 112                 idx = rxq->idx;
 113                 if (idx < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
 114 #ifdef MLX5_PMD_SOFT_COUNTERS
 115                         tmp.q_ipackets[idx] += rxq->stats.ipackets;
 116                         tmp.q_ibytes[idx] += rxq->stats.ibytes;
 117 #endif
 118                         tmp.q_errors[idx] += (rxq->stats.idropped +
 119                                               rxq->stats.rx_nombuf);
 120                 }
 121 #ifdef MLX5_PMD_SOFT_COUNTERS
 122                 tmp.ipackets += rxq->stats.ipackets;
 123                 tmp.ibytes += rxq->stats.ibytes;
 124 #endif
 125                 tmp.ierrors += rxq->stats.idropped;
 126                 tmp.rx_nombuf += rxq->stats.rx_nombuf;
 127         }
 128         for (i = 0; (i != priv->txqs_n); ++i) {
 129                 struct mlx5_txq_data *txq = (*priv->txqs)[i];
 130
 131                 if (txq == NULL)
 132                         continue;
 133                 idx = txq->idx;
 134                 if (idx < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
 135 #ifdef MLX5_PMD_SOFT_COUNTERS
 136                         tmp.q_opackets[idx] += txq->stats.opackets;
 137                         tmp.q_obytes[idx] += txq->stats.obytes;
 138 #endif
 139                 }
 140 #ifdef MLX5_PMD_SOFT_COUNTERS
 141                 tmp.opackets += txq->stats.opackets;
 142                 tmp.obytes += txq->stats.obytes;
 143 #endif
 144                 tmp.oerrors += txq->stats.oerrors;
 145         }
 146         ret = mlx5_os_read_dev_stat(priv, "out_of_buffer", &tmp.imissed);
 147         if (ret == 0) {
 148                 tmp.imissed = (tmp.imissed - stats_ctrl->imissed_base) &
 149                                  (uint64_t)UINT32_MAX;
 150                 wrap_n = stats_ctrl->imissed >> 32;
 151                 if (tmp.imissed < (stats_ctrl->imissed & (uint64_t)UINT32_MAX))
 152                         wrap_n++;
 153                 tmp.imissed |= (wrap_n) << 32;
 154                 stats_ctrl->imissed = tmp.imissed;
 155         } else {
 156                 tmp.imissed = stats_ctrl->imissed;
 157         }
 158 #ifndef MLX5_PMD_SOFT_COUNTERS
 159         /* FIXME: retrieve and add hardware counters. */
 160 #endif
 161         *stats = tmp;
 162         return 0;
 163 }
 164
 165 /**
 166  * DPDK callback to clear device statistics.
 167  *
 168  * @param dev
 169  *   Pointer to Ethernet device structure.
 170  *
 171  * @return
 172  *   always 0 on success and stats is reset
 173  */
 174 int
 175 mlx5_stats_reset(struct rte_eth_dev *dev)
 176 {
 177         struct mlx5_priv *priv = dev->data->dev_private;
 178         struct mlx5_stats_ctrl *stats_ctrl = &priv->stats_ctrl;
 179         unsigned int i;
 180
 181         for (i = 0; (i != priv->rxqs_n); ++i) {
 182                 if ((*priv->rxqs)[i] == NULL)
 183                         continue;
 184                 memset(&(*priv->rxqs)[i]->stats, 0,
 185                        sizeof(struct mlx5_rxq_stats));
 186         }
 187         for (i = 0; (i != priv->txqs_n); ++i) {
 188                 if ((*priv->txqs)[i] == NULL)
 189                         continue;
 190                 memset(&(*priv->txqs)[i]->stats, 0,
 191                        sizeof(struct mlx5_txq_stats));
 192         }
 193         mlx5_os_read_dev_stat(priv, "out_of_buffer", &stats_ctrl->imissed_base);
 194         stats_ctrl->imissed = 0;
 195 #ifndef MLX5_PMD_SOFT_COUNTERS
 196         /* FIXME: reset hardware counters. */
 197 #endif
 198
 199         return 0;
 200 }
 201
 202 /**
 203  * DPDK callback to clear device extended statistics.
 204  *
 205  * @param dev
 206  *   Pointer to Ethernet device structure.
 207  *
 208  * @return
 209  *   0 on success and stats is reset, negative errno value otherwise and
 210  *   rte_errno is set.
 211  */
 212 int
 213 mlx5_xstats_reset(struct rte_eth_dev *dev)
 214 {
 215         struct mlx5_priv *priv = dev->data->dev_private;
 216         struct mlx5_xstats_ctrl *xstats_ctrl = &priv->xstats_ctrl;
 217         int stats_n;
 218         unsigned int i;
 219         unsigned int n = xstats_ctrl->mlx5_stats_n;
 220         uint64_t counters[n];
 221         int ret;
 222
 223         stats_n = mlx5_os_get_stats_n(dev);
 224         if (stats_n < 0) {
 225                 DRV_LOG(ERR, "port %u cannot get stats: %s", dev->data->port_id,
 226                         strerror(-stats_n));
 227                 return stats_n;
 228         }
 229         if (xstats_ctrl->stats_n != stats_n)
 230                 mlx5_os_stats_init(dev);
 231         ret = mlx5_os_read_dev_counters(dev, counters);
 232         if (ret) {
 233                 DRV_LOG(ERR, "port %u cannot read device counters: %s",
 234                         dev->data->port_id, strerror(rte_errno));
 235                 return ret;
 236         }
 237         for (i = 0; i != n; ++i) {
 238                 xstats_ctrl->base[i] = counters[i];
 239                 xstats_ctrl->hw_stats[i] = 0;
 240         }
 241         mlx5_txpp_xstats_reset(dev);
 242         return 0;
 243 }
 244
 245 /**
 246  * DPDK callback to retrieve names of extended device statistics
 247  *
 248  * @param dev
 249  *   Pointer to Ethernet device structure.
 250  * @param[out] xstats_names
 251  *   Buffer to insert names into.
 252  * @param n
 253  *   Number of names.
 254  *
 255  * @return
 256  *   Number of xstats names.
 257  */
 258 int
 259 mlx5_xstats_get_names(struct rte_eth_dev *dev,
 260                       struct rte_eth_xstat_name *xstats_names, unsigned int n)
 261 {
 262         unsigned int i;
 263         struct mlx5_priv *priv = dev->data->dev_private;
 264         struct mlx5_xstats_ctrl *xstats_ctrl = &priv->xstats_ctrl;
 265         unsigned int mlx5_xstats_n = xstats_ctrl->mlx5_stats_n;
 266
 267         if (n >= mlx5_xstats_n && xstats_names) {
 268                 for (i = 0; i != mlx5_xstats_n; ++i) {
 269                         strncpy(xstats_names[i].name,
 270                                 xstats_ctrl->info[i].dpdk_name,
 271                                 RTE_ETH_XSTATS_NAME_SIZE);
 272                         xstats_names[i].name[RTE_ETH_XSTATS_NAME_SIZE - 1] = 0;
 273                 }
 274         }
 275         mlx5_xstats_n = mlx5_txpp_xstats_get_names(dev, xstats_names,
 276                                                    n, mlx5_xstats_n);
 277         return mlx5_xstats_n;
 278 }