drivers/net/cnxk/cnxk_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include "cnxk_ethdev.h"
   6
   7 #define CNXK_NB_RXQ_STATS 5
   8 #define CNXK_NB_TXQ_STATS 4
   9
  10 int
  11 cnxk_nix_stats_get(struct rte_eth_dev *eth_dev, struct rte_eth_stats *stats)
  12 {
  13         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
  14         struct roc_nix *nix = &dev->nix;
  15         struct roc_nix_stats nix_stats;
  16         int rc = 0, i;
  17
  18         rc = roc_nix_stats_get(nix, &nix_stats);
  19         if (rc)
  20                 goto exit;
  21
  22         stats->opackets = nix_stats.tx_ucast;
  23         stats->opackets += nix_stats.tx_mcast;
  24         stats->opackets += nix_stats.tx_bcast;
  25         stats->oerrors = nix_stats.tx_drop;
  26         stats->obytes = nix_stats.tx_octs;
  27
  28         stats->ipackets = nix_stats.rx_ucast;
  29         stats->ipackets += nix_stats.rx_mcast;
  30         stats->ipackets += nix_stats.rx_bcast;
  31         stats->imissed = nix_stats.rx_drop;
  32         stats->ibytes = nix_stats.rx_octs;
  33         stats->ierrors = nix_stats.rx_err;
  34
  35         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) {
  36                 struct roc_nix_stats_queue qstats;
  37                 uint16_t qidx;
  38
  39                 if (dev->txq_stat_map[i] & (1U << 31)) {
  40                         qidx = dev->txq_stat_map[i] & 0xFFFF;
  41                         rc = roc_nix_stats_queue_get(nix, qidx, 0, &qstats);
  42                         if (rc)
  43                                 goto exit;
  44                         stats->q_opackets[i] = qstats.tx_pkts;
  45                         stats->q_obytes[i] = qstats.tx_octs;
  46                         stats->q_errors[i] = qstats.tx_drop_pkts;
  47                 }
  48
  49                 if (dev->rxq_stat_map[i] & (1U << 31)) {
  50                         qidx = dev->rxq_stat_map[i] & 0xFFFF;
  51                         rc = roc_nix_stats_queue_get(nix, qidx, 1, &qstats);
  52                         if (rc)
  53                                 goto exit;
  54                         stats->q_ipackets[i] = qstats.rx_pkts;
  55                         stats->q_ibytes[i] = qstats.rx_octs;
  56                         stats->q_errors[i] += qstats.rx_drop_pkts;
  57                 }
  58         }
  59 exit:
  60         return rc;
  61 }
  62
  63 int
  64 cnxk_nix_stats_reset(struct rte_eth_dev *eth_dev)
  65 {
  66         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
  67
  68         return roc_nix_stats_reset(&dev->nix);
  69 }
  70
  71 int
  72 cnxk_nix_queue_stats_mapping(struct rte_eth_dev *eth_dev, uint16_t queue_id,
  73                              uint8_t stat_idx, uint8_t is_rx)
  74 {
  75         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
  76
  77         if (is_rx) {
  78                 if (queue_id >= dev->nb_rxq)
  79                         return -EINVAL;
  80                 dev->rxq_stat_map[stat_idx] = ((1U << 31) | queue_id);
  81         } else {
  82                 if (queue_id >= dev->nb_txq)
  83                         return -EINVAL;
  84                 dev->txq_stat_map[stat_idx] = ((1U << 31) | queue_id);
  85         }
  86
  87         return 0;
  88 }
  89
  90 int
  91 cnxk_nix_xstats_get(struct rte_eth_dev *eth_dev, struct rte_eth_xstat *xstats,
  92                     unsigned int n)
  93 {
  94         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
  95         struct roc_nix_xstat roc_xstats[n];
  96         struct roc_nix *nix = &dev->nix;
  97         int roc_size, q, idx = 0, size;
  98
  99         roc_size = roc_nix_xstats_get(nix, roc_xstats, n);
 100
 101         if (roc_size < 0)
 102                 return roc_size;
 103
 104         /* Per Queue statistics also returned as part of xstats */
 105         size = roc_size + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 106                (dev->nb_txq * CNXK_NB_TXQ_STATS);
 107
 108         /* If requested array do not have space then return with count */
 109         if (size > (int)n || xstats == NULL)
 110                 return size;
 111
 112         for (idx = 0; idx < roc_size; idx++) {
 113                 xstats[idx].id = roc_xstats[idx].id;
 114                 xstats[idx].value = roc_xstats[idx].value;
 115         }
 116         for (q = 0; q < dev->nb_rxq; q++) {
 117                 struct roc_nix_stats_queue qstats;
 118                 int rc;
 119
 120                 rc = roc_nix_stats_queue_get(nix, q, 1, &qstats);
 121                 if (rc)
 122                         return rc;
 123
 124                 xstats[idx].id = idx;
 125                 xstats[idx].value = qstats.rx_pkts;
 126                 idx++;
 127                 xstats[idx].id = idx;
 128                 xstats[idx].value = qstats.rx_octs;
 129                 idx++;
 130                 xstats[idx].id = idx;
 131                 xstats[idx].value = qstats.rx_drop_pkts;
 132                 idx++;
 133                 xstats[idx].id = idx;
 134                 xstats[idx].value = qstats.rx_drop_octs;
 135                 idx++;
 136                 xstats[idx].id = idx;
 137                 xstats[idx].value = qstats.rx_error_pkts;
 138                 idx++;
 139         }
 140         for (q = 0; q < dev->nb_txq; q++) {
 141                 struct roc_nix_stats_queue qstats;
 142                 int rc;
 143
 144                 rc = roc_nix_stats_queue_get(nix, q, 0, &qstats);
 145                 if (rc)
 146                         return rc;
 147
 148                 xstats[idx].id = idx;
 149                 xstats[idx].value = qstats.tx_pkts;
 150                 idx++;
 151                 xstats[idx].id = idx;
 152                 xstats[idx].value = qstats.tx_octs;
 153                 idx++;
 154                 xstats[idx].id = idx;
 155                 xstats[idx].value = qstats.tx_drop_pkts;
 156                 idx++;
 157                 xstats[idx].id = idx;
 158                 xstats[idx].value = qstats.tx_drop_octs;
 159                 idx++;
 160         }
 161
 162         return size;
 163 }
 164
 165 int
 166 cnxk_nix_xstats_get_names(struct rte_eth_dev *eth_dev,
 167                           struct rte_eth_xstat_name *xstats_names,
 168                           unsigned int limit)
 169 {
 170         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 171         struct roc_nix_xstat_name roc_xstats_name[limit];
 172         struct roc_nix *nix = &dev->nix;
 173         int roc_size, size, i, q;
 174
 175         roc_size = roc_nix_xstats_names_get(nix, NULL, 0);
 176         /* Per Queue statistics also returned as part of xstats */
 177         size = roc_size + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 178                (dev->nb_txq * CNXK_NB_TXQ_STATS);
 179
 180         if (xstats_names == NULL)
 181                 return size;
 182
 183         if ((int)limit < size && xstats_names != NULL)
 184                 return size;
 185
 186         roc_size = roc_nix_xstats_names_get(nix, roc_xstats_name, limit);
 187
 188         for (i = 0; i < roc_size; i++)
 189                 rte_strscpy(xstats_names[i].name, roc_xstats_name[i].name,
 190                             sizeof(xstats_names[i].name));
 191
 192         for (q = 0; q < dev->nb_rxq; q++) {
 193                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 194                          "rxq_%d_pkts", q);
 195                 i++;
 196                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 197                          "rxq_%d_octs", q);
 198                 i++;
 199                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 200                          "rxq_%d_drop_pkts", q);
 201                 i++;
 202                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 203                          "rxq_%d_drop_octs", q);
 204                 i++;
 205                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 206                          "rxq_%d_err_pkts", q);
 207                 i++;
 208         }
 209
 210         for (q = 0; q < dev->nb_txq; q++) {
 211                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 212                          "txq_%d_pkts", q);
 213                 i++;
 214                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 215                          "txq_%d_octs", q);
 216                 i++;
 217                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 218                          "txq_%d_drop_pkts", q);
 219                 i++;
 220                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
 221                          "txq_%d_drop_octs", q);
 222                 i++;
 223         }
 224
 225         return size;
 226 }
 227
 228 int
 229 cnxk_nix_xstats_get_names_by_id(struct rte_eth_dev *eth_dev,
 230                                 const uint64_t *ids,
 231                                 struct rte_eth_xstat_name *xstats_names,
 232                                 unsigned int limit)
 233 {
 234         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 235         uint32_t nix_cnt = roc_nix_xstats_names_get(&dev->nix, NULL, 0);
 236         uint32_t stat_cnt = nix_cnt + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 237                             (dev->nb_txq * CNXK_NB_TXQ_STATS);
 238         struct rte_eth_xstat_name xnames[stat_cnt];
 239         uint32_t i;
 240
 241         if (limit < stat_cnt && ids == NULL)
 242                 return stat_cnt;
 243
 244         if (limit > stat_cnt)
 245                 return -EINVAL;
 246
 247         if (xstats_names == NULL)
 248                 return -ENOMEM;
 249
 250         cnxk_nix_xstats_get_names(eth_dev, xnames, stat_cnt);
 251
 252         for (i = 0; i < limit; i++) {
 253                 if (ids[i] >= stat_cnt)
 254                         return -EINVAL;
 255
 256                 rte_strscpy(xstats_names[i].name, xnames[ids[i]].name,
 257                             sizeof(xstats_names[i].name));
 258         }
 259
 260         return limit;
 261 }
 262
 263 int
 264 cnxk_nix_xstats_get_by_id(struct rte_eth_dev *eth_dev, const uint64_t *ids,
 265                           uint64_t *values, unsigned int n)
 266 {
 267         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 268         uint32_t nix_cnt = roc_nix_xstats_names_get(&dev->nix, NULL, 0);
 269         uint32_t stat_cnt = nix_cnt + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 270                             (dev->nb_txq * CNXK_NB_TXQ_STATS);
 271         struct rte_eth_xstat xstats[stat_cnt];
 272         uint32_t i;
 273
 274         if (n < stat_cnt && ids == NULL)
 275                 return stat_cnt;
 276
 277         if (n > stat_cnt)
 278                 return -EINVAL;
 279
 280         if (values == NULL)
 281                 return -ENOMEM;
 282
 283         cnxk_nix_xstats_get(eth_dev, xstats, stat_cnt);
 284
 285         for (i = 0; i < n; i++) {
 286                 if (ids[i] >= stat_cnt)
 287                         return -EINVAL;
 288                 values[i] = xstats[ids[i]].value;
 289         }
 290
 291         return n;
 292 }
 293
 294 int
 295 cnxk_nix_xstats_reset(struct rte_eth_dev *eth_dev)
 296 {
 297         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 298         struct roc_nix *nix = &dev->nix;
 299         int rc = 0, i;
 300
 301         rc = roc_nix_stats_reset(nix);
 302         if (rc)
 303                 goto exit;
 304
 305         /* Reset Rx Queues */
 306         for (i = 0; i < dev->nb_rxq; i++) {
 307                 rc = roc_nix_stats_queue_reset(nix, i, 1);
 308                 if (rc)
 309                         goto exit;
 310         }
 311
 312         /* Reset Tx Queues */
 313         for (i = 0; i < dev->nb_txq; i++) {
 314                 rc = roc_nix_stats_queue_reset(nix, i, 0);
 315                 if (rc)
 316                         goto exit;
 317         }
 318
 319 exit:
 320         return rc;
 321 }