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_num_xstats_get(nix);
 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                                 struct rte_eth_xstat_name *xstats_names,
 231                                 const uint64_t *ids, unsigned int limit)
 232 {
 233         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 234         uint32_t nix_cnt = roc_nix_num_xstats_get(&dev->nix);
 235         uint32_t stat_cnt = nix_cnt + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 236                             (dev->nb_txq * CNXK_NB_TXQ_STATS);
 237         struct rte_eth_xstat_name xnames[stat_cnt];
 238         uint32_t i;
 239
 240         if (limit < stat_cnt && ids == NULL)
 241                 return stat_cnt;
 242
 243         if (limit > stat_cnt)
 244                 return -EINVAL;
 245
 246         if (xstats_names == NULL)
 247                 return -ENOMEM;
 248
 249         cnxk_nix_xstats_get_names(eth_dev, xnames, stat_cnt);
 250
 251         for (i = 0; i < limit; i++) {
 252                 if (ids[i] >= stat_cnt)
 253                         return -EINVAL;
 254
 255                 rte_strscpy(xstats_names[i].name, xnames[ids[i]].name,
 256                             sizeof(xstats_names[i].name));
 257         }
 258
 259         return limit;
 260 }
 261
 262 int
 263 cnxk_nix_xstats_get_by_id(struct rte_eth_dev *eth_dev, const uint64_t *ids,
 264                           uint64_t *values, unsigned int n)
 265 {
 266         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 267         uint32_t nix_cnt = roc_nix_num_xstats_get(&dev->nix);
 268         uint32_t stat_cnt = nix_cnt + (dev->nb_rxq * CNXK_NB_RXQ_STATS) +
 269                             (dev->nb_txq * CNXK_NB_TXQ_STATS);
 270         struct rte_eth_xstat xstats[stat_cnt];
 271         uint32_t i;
 272
 273         if (n < stat_cnt && ids == NULL)
 274                 return stat_cnt;
 275
 276         if (n > stat_cnt)
 277                 return -EINVAL;
 278
 279         if (values == NULL)
 280                 return -ENOMEM;
 281
 282         cnxk_nix_xstats_get(eth_dev, xstats, stat_cnt);
 283
 284         for (i = 0; i < n; i++) {
 285                 if (ids[i] >= stat_cnt)
 286                         return -EINVAL;
 287                 values[i] = xstats[ids[i]].value;
 288         }
 289
 290         return n;
 291 }
 292
 293 int
 294 cnxk_nix_xstats_reset(struct rte_eth_dev *eth_dev)
 295 {
 296         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 297         struct roc_nix *nix = &dev->nix;
 298         int rc = 0, i;
 299
 300         rc = roc_nix_stats_reset(nix);
 301         if (rc)
 302                 goto exit;
 303
 304         /* Reset Rx Queues */
 305         for (i = 0; i < dev->nb_rxq; i++) {
 306                 rc = roc_nix_stats_queue_reset(nix, i, 1);
 307                 if (rc)
 308                         goto exit;
 309         }
 310
 311         /* Reset Tx Queues */
 312         for (i = 0; i < dev->nb_txq; i++) {
 313                 rc = roc_nix_stats_queue_reset(nix, i, 0);
 314                 if (rc)
 315                         goto exit;
 316         }
 317
 318 exit:
 319         return rc;
 320 }