drivers/net/softnic/rte_eth_softnic_meter.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include <rte_mtr.h>
  10 #include <rte_mtr_driver.h>
  11
  12 #include "rte_eth_softnic_internals.h"
  13
  14 int
  15 softnic_mtr_init(struct pmd_internals *p)
  16 {
  17         /* Initialize meter profiles list */
  18         TAILQ_INIT(&p->mtr.meter_profiles);
  19
  20         /* Initialize MTR objects list */
  21         TAILQ_INIT(&p->mtr.mtrs);
  22
  23         return 0;
  24 }
  25
  26 void
  27 softnic_mtr_free(struct pmd_internals *p)
  28 {
  29         /* Remove MTR objects */
  30         for ( ; ; ) {
  31                 struct softnic_mtr *m;
  32
  33                 m = TAILQ_FIRST(&p->mtr.mtrs);
  34                 if (m == NULL)
  35                         break;
  36
  37                 TAILQ_REMOVE(&p->mtr.mtrs, m, node);
  38                 free(m);
  39         }
  40
  41         /* Remove meter profiles */
  42         for ( ; ; ) {
  43                 struct softnic_mtr_meter_profile *mp;
  44
  45                 mp = TAILQ_FIRST(&p->mtr.meter_profiles);
  46                 if (mp == NULL)
  47                         break;
  48
  49                 TAILQ_REMOVE(&p->mtr.meter_profiles, mp, node);
  50                 free(mp);
  51         }
  52 }
  53
  54 struct softnic_mtr_meter_profile *
  55 softnic_mtr_meter_profile_find(struct pmd_internals *p,
  56         uint32_t meter_profile_id)
  57 {
  58         struct softnic_mtr_meter_profile_list *mpl = &p->mtr.meter_profiles;
  59         struct softnic_mtr_meter_profile *mp;
  60
  61         TAILQ_FOREACH(mp, mpl, node)
  62                 if (meter_profile_id == mp->meter_profile_id)
  63                         return mp;
  64
  65         return NULL;
  66 }
  67
  68 enum rte_table_action_policer
  69 softnic_table_action_policer(enum rte_mtr_policer_action action)
  70 {
  71         switch (action) {
  72         case MTR_POLICER_ACTION_COLOR_GREEN:
  73                 return RTE_TABLE_ACTION_POLICER_COLOR_GREEN;
  74
  75                 /* FALLTHROUGH */
  76         case MTR_POLICER_ACTION_COLOR_YELLOW:
  77                 return RTE_TABLE_ACTION_POLICER_COLOR_YELLOW;
  78
  79                 /* FALLTHROUGH */
  80         case MTR_POLICER_ACTION_COLOR_RED:
  81                 return RTE_TABLE_ACTION_POLICER_COLOR_RED;
  82
  83                 /* FALLTHROUGH */
  84         default:
  85                 return RTE_TABLE_ACTION_POLICER_DROP;
  86         }
  87 }
  88
  89 static int
  90 meter_profile_check(struct rte_eth_dev *dev,
  91         uint32_t meter_profile_id,
  92         struct rte_mtr_meter_profile *profile,
  93         struct rte_mtr_error *error)
  94 {
  95         struct pmd_internals *p = dev->data->dev_private;
  96         struct softnic_mtr_meter_profile *mp;
  97
  98         /* Meter profile ID must be valid. */
  99         if (meter_profile_id == UINT32_MAX)
 100                 return -rte_mtr_error_set(error,
 101                         EINVAL,
 102                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 103                         NULL,
 104                         "Meter profile id not valid");
 105
 106         /* Meter profile must not exist. */
 107         mp = softnic_mtr_meter_profile_find(p, meter_profile_id);
 108         if (mp)
 109                 return -rte_mtr_error_set(error,
 110                         EEXIST,
 111                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 112                         NULL,
 113                         "Meter prfile already exists");
 114
 115         /* Profile must not be NULL. */
 116         if (profile == NULL)
 117                 return -rte_mtr_error_set(error,
 118                         EINVAL,
 119                         RTE_MTR_ERROR_TYPE_METER_PROFILE,
 120                         NULL,
 121                         "profile null");
 122
 123         /* Traffic metering algorithm : TRTCM_RFC2698 */
 124         if (profile->alg != RTE_MTR_TRTCM_RFC2698)
 125                 return -rte_mtr_error_set(error,
 126                         EINVAL,
 127                         RTE_MTR_ERROR_TYPE_METER_PROFILE,
 128                         NULL,
 129                         "Metering alg not supported");
 130
 131         return 0;
 132 }
 133
 134 /* MTR meter profile add */
 135 static int
 136 pmd_mtr_meter_profile_add(struct rte_eth_dev *dev,
 137         uint32_t meter_profile_id,
 138         struct rte_mtr_meter_profile *profile,
 139         struct rte_mtr_error *error)
 140 {
 141         struct pmd_internals *p = dev->data->dev_private;
 142         struct softnic_mtr_meter_profile_list *mpl = &p->mtr.meter_profiles;
 143         struct softnic_mtr_meter_profile *mp;
 144         int status;
 145
 146         /* Check input params */
 147         status = meter_profile_check(dev, meter_profile_id, profile, error);
 148         if (status)
 149                 return status;
 150
 151         /* Memory allocation */
 152         mp = calloc(1, sizeof(struct softnic_mtr_meter_profile));
 153         if (mp == NULL)
 154                 return -rte_mtr_error_set(error,
 155                         ENOMEM,
 156                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 157                         NULL,
 158                         "Memory alloc failed");
 159
 160         /* Fill in */
 161         mp->meter_profile_id = meter_profile_id;
 162         memcpy(&mp->params, profile, sizeof(mp->params));
 163
 164         /* Add to list */
 165         TAILQ_INSERT_TAIL(mpl, mp, node);
 166
 167         return 0;
 168 }
 169
 170 /* MTR meter profile delete */
 171 static int
 172 pmd_mtr_meter_profile_delete(struct rte_eth_dev *dev,
 173         uint32_t meter_profile_id,
 174         struct rte_mtr_error *error)
 175 {
 176         struct pmd_internals *p = dev->data->dev_private;
 177         struct softnic_mtr_meter_profile *mp;
 178
 179         /* Meter profile must exist */
 180         mp = softnic_mtr_meter_profile_find(p, meter_profile_id);
 181         if (mp == NULL)
 182                 return -rte_mtr_error_set(error,
 183                         EINVAL,
 184                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 185                         NULL,
 186                         "Meter profile id invalid");
 187
 188         /* Check unused */
 189         if (mp->n_users)
 190                 return -rte_mtr_error_set(error,
 191                         EBUSY,
 192                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 193                         NULL,
 194                         "Meter profile in use");
 195
 196         /* Remove from list */
 197         TAILQ_REMOVE(&p->mtr.meter_profiles, mp, node);
 198         free(mp);
 199
 200         return 0;
 201 }
 202
 203 struct softnic_mtr *
 204 softnic_mtr_find(struct pmd_internals *p, uint32_t mtr_id)
 205 {
 206         struct softnic_mtr_list *ml = &p->mtr.mtrs;
 207         struct softnic_mtr *m;
 208
 209         TAILQ_FOREACH(m, ml, node)
 210                 if (m->mtr_id == mtr_id)
 211                         return m;
 212
 213         return NULL;
 214 }
 215
 216
 217 static int
 218 mtr_check(struct pmd_internals *p,
 219         uint32_t mtr_id,
 220         struct rte_mtr_params *params,
 221         int shared,
 222         struct rte_mtr_error *error)
 223 {
 224         /* MTR id valid  */
 225         if (softnic_mtr_find(p, mtr_id))
 226                 return -rte_mtr_error_set(error,
 227                         EEXIST,
 228                         RTE_MTR_ERROR_TYPE_MTR_ID,
 229                         NULL,
 230                         "MTR object already exists");
 231
 232         /* MTR params must not be NULL */
 233         if (params == NULL)
 234                 return -rte_mtr_error_set(error,
 235                         EINVAL,
 236                         RTE_MTR_ERROR_TYPE_MTR_PARAMS,
 237                         NULL,
 238                         "MTR object params null");
 239
 240         /* Previous meter color not supported */
 241         if (params->use_prev_mtr_color)
 242                 return -rte_mtr_error_set(error,
 243                         EINVAL,
 244                         RTE_MTR_ERROR_TYPE_MTR_PARAMS,
 245                         NULL,
 246                         "Previous meter color not supported");
 247
 248         /* Shared MTR object not supported */
 249         if (shared)
 250                 return -rte_mtr_error_set(error,
 251                         EINVAL,
 252                         RTE_MTR_ERROR_TYPE_SHARED,
 253                         NULL,
 254                         "Shared MTR object not supported");
 255
 256         return 0;
 257 }
 258
 259 /* MTR object create */
 260 static int
 261 pmd_mtr_create(struct rte_eth_dev *dev,
 262         uint32_t mtr_id,
 263         struct rte_mtr_params *params,
 264         int shared,
 265         struct rte_mtr_error *error)
 266 {
 267         struct pmd_internals *p = dev->data->dev_private;
 268         struct softnic_mtr_list *ml = &p->mtr.mtrs;
 269         struct softnic_mtr_meter_profile *mp;
 270         struct softnic_mtr *m;
 271         int status;
 272
 273         /* Check parameters */
 274         status = mtr_check(p, mtr_id, params, shared, error);
 275         if (status)
 276                 return status;
 277
 278         /* Meter profile must exist */
 279         mp = softnic_mtr_meter_profile_find(p, params->meter_profile_id);
 280         if (mp == NULL)
 281                 return -rte_mtr_error_set(error,
 282                         EINVAL,
 283                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 284                         NULL,
 285                         "Meter profile id not valid");
 286
 287         /* Memory allocation */
 288         m = calloc(1, sizeof(struct softnic_mtr));
 289         if (m == NULL)
 290                 return -rte_mtr_error_set(error,
 291                         ENOMEM,
 292                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 293                         NULL,
 294                         "Memory alloc failed");
 295
 296         /* Fill in */
 297         m->mtr_id = mtr_id;
 298         memcpy(&m->params, params, sizeof(m->params));
 299
 300         /* Add to list */
 301         TAILQ_INSERT_TAIL(ml, m, node);
 302
 303         /* Update dependencies */
 304         mp->n_users++;
 305
 306         return 0;
 307 }
 308
 309 /* MTR object destroy */
 310 static int
 311 pmd_mtr_destroy(struct rte_eth_dev *dev,
 312         uint32_t mtr_id,
 313         struct rte_mtr_error *error)
 314 {
 315         struct pmd_internals *p = dev->data->dev_private;
 316         struct softnic_mtr_list *ml = &p->mtr.mtrs;
 317         struct softnic_mtr_meter_profile *mp;
 318         struct softnic_mtr *m;
 319
 320         /* MTR object must exist */
 321         m = softnic_mtr_find(p, mtr_id);
 322         if (m == NULL)
 323                 return -rte_mtr_error_set(error,
 324                         EEXIST,
 325                         RTE_MTR_ERROR_TYPE_MTR_ID,
 326                         NULL,
 327                         "MTR object id not valid");
 328
 329         /* MTR object must not have any owner */
 330         if (m->flow != NULL)
 331                 return -rte_mtr_error_set(error,
 332                         EINVAL,
 333                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 334                         NULL,
 335                         "MTR object is being used");
 336
 337         /* Get meter profile */
 338         mp = softnic_mtr_meter_profile_find(p, m->params.meter_profile_id);
 339         if (mp == NULL)
 340                 return -rte_mtr_error_set(error,
 341                         EINVAL,
 342                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 343                         NULL,
 344                         "MTR object meter profile invalid");
 345
 346         /* Update dependencies */
 347         mp->n_users--;
 348
 349         /* Remove from list */
 350         TAILQ_REMOVE(ml, m, node);
 351         free(m);
 352
 353         return 0;
 354 }
 355
 356 /* MTR object meter profile update */
 357 static int
 358 pmd_mtr_meter_profile_update(struct rte_eth_dev *dev,
 359         uint32_t mtr_id,
 360         uint32_t meter_profile_id,
 361         struct rte_mtr_error *error)
 362 {
 363         struct pmd_internals *p = dev->data->dev_private;
 364         struct softnic_mtr_meter_profile *mp_new, *mp_old;
 365         struct softnic_mtr *m;
 366         int status;
 367
 368         /* MTR object id must be valid */
 369         m = softnic_mtr_find(p, mtr_id);
 370         if (m == NULL)
 371                 return -rte_mtr_error_set(error,
 372                         EEXIST,
 373                         RTE_MTR_ERROR_TYPE_MTR_ID,
 374                         NULL,
 375                         "MTR object id not valid");
 376
 377         /* Meter profile id must be valid */
 378         mp_new = softnic_mtr_meter_profile_find(p, meter_profile_id);
 379         if (mp_new == NULL)
 380                 return -rte_mtr_error_set(error,
 381                         EINVAL,
 382                         RTE_MTR_ERROR_TYPE_METER_PROFILE_ID,
 383                         NULL,
 384                         "Meter profile not valid");
 385
 386         /* MTR object already set to meter profile id */
 387         if (m->params.meter_profile_id == meter_profile_id)
 388                 return 0;
 389
 390         /*  MTR object owner table update */
 391         if (m->flow) {
 392                 uint32_t table_id = m->flow->table_id;
 393                 struct softnic_table *table = &m->flow->pipeline->table[table_id];
 394                 struct softnic_table_rule_action action;
 395
 396                 if (!softnic_pipeline_table_meter_profile_find(table,
 397                         meter_profile_id)) {
 398                         struct rte_table_action_meter_profile profile;
 399
 400                         memset(&profile, 0, sizeof(profile));
 401
 402                         profile.alg = RTE_TABLE_ACTION_METER_TRTCM;
 403                         profile.trtcm.cir = mp_new->params.trtcm_rfc2698.cir;
 404                         profile.trtcm.pir = mp_new->params.trtcm_rfc2698.pir;
 405                         profile.trtcm.cbs = mp_new->params.trtcm_rfc2698.cbs;
 406                         profile.trtcm.pbs = mp_new->params.trtcm_rfc2698.pbs;
 407
 408                         /* Add meter profile to pipeline table */
 409                         status = softnic_pipeline_table_mtr_profile_add(p,
 410                                         m->flow->pipeline->name,
 411                                         table_id,
 412                                         meter_profile_id,
 413                                         &profile);
 414                         if (status)
 415                                 return -rte_mtr_error_set(error,
 416                                         EINVAL,
 417                                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 418                                         NULL,
 419                                         "Table meter profile add failed");
 420                 }
 421
 422                 /* Set meter action */
 423                 memcpy(&action, &m->flow->action, sizeof(action));
 424
 425                 action.mtr.mtr[0].meter_profile_id = meter_profile_id;
 426
 427                 /* Re-add rule */
 428                 status = softnic_pipeline_table_rule_add(p,
 429                         m->flow->pipeline->name,
 430                         table_id,
 431                         &m->flow->match,
 432                         &action,
 433                         &m->flow->data);
 434                 if (status)
 435                         return -rte_mtr_error_set(error,
 436                                 EINVAL,
 437                                 RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 438                                 NULL,
 439                                 "Pipeline table rule add failed");
 440
 441                 /* Flow: update meter action */
 442                 memcpy(&m->flow->action, &action, sizeof(m->flow->action));
 443         }
 444
 445         mp_old = softnic_mtr_meter_profile_find(p, m->params.meter_profile_id);
 446
 447         /* Meter: Set meter profile */
 448         m->params.meter_profile_id = meter_profile_id;
 449
 450         /* Update dependencies*/
 451         mp_old->n_users--;
 452         mp_new->n_users++;
 453
 454         return 0;
 455 }
 456
 457 /* MTR object meter DSCP table update */
 458 static int
 459 pmd_mtr_meter_dscp_table_update(struct rte_eth_dev *dev,
 460         uint32_t mtr_id,
 461         enum rte_color *dscp_table,
 462         struct rte_mtr_error *error)
 463 {
 464         struct pmd_internals *p = dev->data->dev_private;
 465         struct rte_table_action_dscp_table dt;
 466         struct pipeline *pipeline;
 467         struct softnic_table *table;
 468         struct softnic_mtr *m;
 469         uint32_t table_id, i;
 470         int status;
 471
 472         /* MTR object id must be valid */
 473         m = softnic_mtr_find(p, mtr_id);
 474         if (m == NULL)
 475                 return -rte_mtr_error_set(error,
 476                         EEXIST,
 477                         RTE_MTR_ERROR_TYPE_MTR_ID,
 478                         NULL,
 479                         "MTR object id not valid");
 480
 481         /* MTR object owner valid? */
 482         if (m->flow == NULL)
 483                 return 0;
 484
 485         pipeline = m->flow->pipeline;
 486         table_id = m->flow->table_id;
 487         table = &pipeline->table[table_id];
 488
 489         memcpy(&dt, &table->dscp_table, sizeof(dt));
 490         for (i = 0; i < RTE_DIM(dt.entry); i++)
 491                 dt.entry[i].color = (enum rte_color)dscp_table[i];
 492
 493         /* Update table */
 494         status = softnic_pipeline_table_dscp_table_update(p,
 495                         pipeline->name,
 496                         table_id,
 497                         UINT64_MAX,
 498                         &dt);
 499         if (status)
 500                 return -rte_mtr_error_set(error,
 501                         EINVAL,
 502                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 503                         NULL,
 504                         "Table action dscp table update failed");
 505
 506         return 0;
 507 }
 508
 509 /* MTR object policer action update */
 510 static int
 511 pmd_mtr_policer_actions_update(struct rte_eth_dev *dev,
 512         uint32_t mtr_id,
 513         uint32_t action_mask,
 514         enum rte_mtr_policer_action *actions,
 515         struct rte_mtr_error *error)
 516 {
 517         struct pmd_internals *p = dev->data->dev_private;
 518         struct softnic_mtr *m;
 519         uint32_t i;
 520         int status;
 521
 522         /* MTR object id must be valid */
 523         m = softnic_mtr_find(p, mtr_id);
 524         if (m == NULL)
 525                 return -rte_mtr_error_set(error,
 526                         EEXIST,
 527                         RTE_MTR_ERROR_TYPE_MTR_ID,
 528                         NULL,
 529                         "MTR object id not valid");
 530
 531         /* Valid policer actions */
 532         if (actions == NULL)
 533                 return -rte_mtr_error_set(error,
 534                         EINVAL,
 535                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 536                         NULL,
 537                         "Invalid actions");
 538
 539         for (i = 0; i < RTE_COLORS; i++) {
 540                 if (action_mask & (1 << i)) {
 541                         if (actions[i] != MTR_POLICER_ACTION_COLOR_GREEN  &&
 542                                 actions[i] != MTR_POLICER_ACTION_COLOR_YELLOW &&
 543                                 actions[i] != MTR_POLICER_ACTION_COLOR_RED &&
 544                                 actions[i] != MTR_POLICER_ACTION_DROP) {
 545                                 return -rte_mtr_error_set(error,
 546                                         EINVAL,
 547                                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 548                                         NULL,
 549                                         " Invalid action value");
 550                         }
 551                 }
 552         }
 553
 554         /* MTR object owner valid? */
 555         if (m->flow) {
 556                 struct pipeline *pipeline = m->flow->pipeline;
 557                 struct softnic_table *table = &pipeline->table[m->flow->table_id];
 558                 struct softnic_table_rule_action action;
 559
 560                 memcpy(&action, &m->flow->action, sizeof(action));
 561
 562                 /* Set action */
 563                 for (i = 0; i < RTE_COLORS; i++)
 564                         if (action_mask & (1 << i))
 565                                 action.mtr.mtr[0].policer[i] =
 566                                         softnic_table_action_policer(actions[i]);
 567
 568                 /* Re-add the rule */
 569                 status = softnic_pipeline_table_rule_add(p,
 570                         pipeline->name,
 571                         m->flow->table_id,
 572                         &m->flow->match,
 573                         &action,
 574                         &m->flow->data);
 575                 if (status)
 576                         return -rte_mtr_error_set(error,
 577                                 EINVAL,
 578                                 RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 579                                 NULL,
 580                                 "Pipeline table rule re-add failed");
 581
 582                 /* Flow: Update meter action */
 583                 memcpy(&m->flow->action, &action, sizeof(m->flow->action));
 584
 585                 /* Reset the meter stats */
 586                 rte_table_action_meter_read(table->a, m->flow->data,
 587                         1, NULL, 1);
 588         }
 589
 590         /* Meter: Update policer actions */
 591         for (i = 0; i < RTE_COLORS; i++)
 592                 if (action_mask & (1 << i))
 593                         m->params.action[i] = actions[i];
 594
 595         return 0;
 596 }
 597
 598 #define MTR_STATS_PKTS_DEFAULT (RTE_MTR_STATS_N_PKTS_GREEN | \
 599                                 RTE_MTR_STATS_N_PKTS_YELLOW | \
 600                                 RTE_MTR_STATS_N_PKTS_RED | \
 601                                 RTE_MTR_STATS_N_PKTS_DROPPED)
 602
 603 #define MTR_STATS_BYTES_DEFAULT (RTE_MTR_STATS_N_BYTES_GREEN | \
 604                                 RTE_MTR_STATS_N_BYTES_YELLOW | \
 605                                 RTE_MTR_STATS_N_BYTES_RED | \
 606                                 RTE_MTR_STATS_N_BYTES_DROPPED)
 607
 608 /* MTR object stats read */
 609 static void
 610 mtr_stats_convert(struct softnic_mtr *m,
 611         struct rte_table_action_mtr_counters_tc *in,
 612         struct rte_mtr_stats *out,
 613         uint64_t *out_mask)
 614 {
 615         memset(&out, 0, sizeof(out));
 616         *out_mask = 0;
 617
 618         if (in->n_packets_valid) {
 619                 uint32_t i;
 620
 621                 for (i = 0; i < RTE_COLORS; i++) {
 622                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_GREEN)
 623                                 out->n_pkts[RTE_COLOR_GREEN] += in->n_packets[i];
 624
 625                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_YELLOW)
 626                                 out->n_pkts[RTE_COLOR_YELLOW] += in->n_packets[i];
 627
 628                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_RED)
 629                                 out->n_pkts[RTE_COLOR_RED] += in->n_packets[i];
 630
 631                         if (m->params.action[i] == MTR_POLICER_ACTION_DROP)
 632                                 out->n_pkts_dropped += in->n_packets[i];
 633                 }
 634
 635                 *out_mask |= MTR_STATS_PKTS_DEFAULT;
 636         }
 637
 638         if (in->n_bytes_valid) {
 639                 uint32_t i;
 640
 641                 for (i = 0; i < RTE_COLORS; i++) {
 642                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_GREEN)
 643                                 out->n_bytes[RTE_COLOR_GREEN] += in->n_bytes[i];
 644
 645                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_YELLOW)
 646                                 out->n_bytes[RTE_COLOR_YELLOW] += in->n_bytes[i];
 647
 648                         if (m->params.action[i] == MTR_POLICER_ACTION_COLOR_RED)
 649                                 out->n_bytes[RTE_COLOR_RED] += in->n_bytes[i];
 650
 651                         if (m->params.action[i] == MTR_POLICER_ACTION_DROP)
 652                                 out->n_bytes_dropped += in->n_bytes[i];
 653                 }
 654
 655                 *out_mask |= MTR_STATS_BYTES_DEFAULT;
 656         }
 657 }
 658
 659 /* MTR object stats read */
 660 static int
 661 pmd_mtr_stats_read(struct rte_eth_dev *dev,
 662         uint32_t mtr_id,
 663         struct rte_mtr_stats *stats,
 664         uint64_t *stats_mask,
 665         int clear,
 666         struct rte_mtr_error *error)
 667 {
 668         struct pmd_internals *p = dev->data->dev_private;
 669         struct rte_table_action_mtr_counters counters;
 670         struct pipeline *pipeline;
 671         struct softnic_table *table;
 672         struct softnic_mtr *m;
 673         int status;
 674
 675         /* MTR object id must be valid */
 676         m = softnic_mtr_find(p, mtr_id);
 677         if (m == NULL)
 678                 return -rte_mtr_error_set(error,
 679                         EEXIST,
 680                         RTE_MTR_ERROR_TYPE_MTR_ID,
 681                         NULL,
 682                         "MTR object id not valid");
 683
 684         /* MTR meter object owner valid? */
 685         if (m->flow == NULL) {
 686                 if (stats != NULL)
 687                         memset(stats, 0, sizeof(*stats));
 688
 689                 if (stats_mask)
 690                         *stats_mask = MTR_STATS_PKTS_DEFAULT |
 691                                 MTR_STATS_BYTES_DEFAULT;
 692
 693                 return 0;
 694         }
 695
 696         pipeline = m->flow->pipeline;
 697         table = &pipeline->table[m->flow->table_id];
 698
 699         /* Meter stats read. */
 700         status = rte_table_action_meter_read(table->a,
 701                 m->flow->data,
 702                 1,
 703                 &counters,
 704                 clear);
 705         if (status)
 706                 return -rte_mtr_error_set(error,
 707                         EINVAL,
 708                         RTE_MTR_ERROR_TYPE_UNSPECIFIED,
 709                         NULL,
 710                         "Meter stats read failed");
 711
 712         /* Stats format conversion. */
 713         if (stats || stats_mask) {
 714                 struct rte_mtr_stats s;
 715                 uint64_t s_mask = 0;
 716
 717                 mtr_stats_convert(m,
 718                         &counters.stats[0],
 719                         &s,
 720                         &s_mask);
 721
 722                 if (stats)
 723                         memcpy(stats, &s, sizeof(*stats));
 724
 725                 if (stats_mask)
 726                         *stats_mask = s_mask;
 727         }
 728
 729         return 0;
 730 }
 731
 732 const struct rte_mtr_ops pmd_mtr_ops = {
 733         .capabilities_get = NULL,
 734
 735         .meter_profile_add = pmd_mtr_meter_profile_add,
 736         .meter_profile_delete = pmd_mtr_meter_profile_delete,
 737
 738         .create = pmd_mtr_create,
 739         .destroy = pmd_mtr_destroy,
 740         .meter_enable = NULL,
 741         .meter_disable = NULL,
 742
 743         .meter_profile_update = pmd_mtr_meter_profile_update,
 744         .meter_dscp_table_update = pmd_mtr_meter_dscp_table_update,
 745         .policer_actions_update = pmd_mtr_policer_actions_update,
 746         .stats_update = NULL,
 747
 748         .stats_read = pmd_mtr_stats_read,
 749 };