app/test-pmd/cmdline_mtr.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <cmdline_parse.h>
   6 #include <cmdline_parse_num.h>
   7 #include <cmdline_parse_string.h>
   8
   9 #include <rte_ethdev.h>
  10 #include <rte_flow.h>
  11 #include <rte_mtr.h>
  12
  13 #include "testpmd.h"
  14 #include "cmdline_mtr.h"
  15
  16 #define PARSE_DELIMITER                         " \f\n\r\t\v"
  17 #define MAX_DSCP_TABLE_ENTRIES          64
  18
  19 /** Display Meter Error Message */
  20 static void
  21 print_err_msg(struct rte_mtr_error *error)
  22 {
  23         static const char *const errstrlist[] = {
  24                 [RTE_MTR_ERROR_TYPE_NONE] = "no error",
  25                 [RTE_MTR_ERROR_TYPE_UNSPECIFIED] = "cause unspecified",
  26                 [RTE_MTR_ERROR_TYPE_METER_PROFILE_ID] = "meter profile id",
  27                 [RTE_MTR_ERROR_TYPE_METER_PROFILE] = "meter profile null",
  28                 [RTE_MTR_ERROR_TYPE_MTR_ID] = "meter id",
  29                 [RTE_MTR_ERROR_TYPE_MTR_PARAMS] = "meter params null",
  30                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_GREEN]
  31                         = "policer action(green)",
  32                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_YELLOW]
  33                         = "policer action(yellow)",
  34                 [RTE_MTR_ERROR_TYPE_POLICER_ACTION_RED]
  35                         = "policer action(red)",
  36                 [RTE_MTR_ERROR_TYPE_STATS_MASK] = "stats mask",
  37                 [RTE_MTR_ERROR_TYPE_STATS] = "stats",
  38                 [RTE_MTR_ERROR_TYPE_SHARED]
  39                         = "shared meter",
  40                 [RTE_MTR_ERROR_TYPE_METER_POLICY_ID] = "meter policy id",
  41                 [RTE_MTR_ERROR_TYPE_METER_POLICY] = "meter policy null",
  42         };
  43
  44         const char *errstr;
  45         char buf[64];
  46
  47         if ((unsigned int)error->type >= RTE_DIM(errstrlist) ||
  48                 !errstrlist[error->type])
  49                 errstr = "unknown type";
  50         else
  51                 errstr = errstrlist[error->type];
  52
  53         if (error->cause)
  54                 snprintf(buf, sizeof(buf), "cause: %p, ", error->cause);
  55
  56         printf("%s: %s%s (error %d)\n", errstr, error->cause ? buf : "",
  57                 error->message ? error->message : "(no stated reason)",
  58                 error->type);
  59 }
  60
  61 void
  62 print_mtr_err_msg(struct rte_mtr_error *error)
  63 {
  64         print_err_msg(error);
  65 }
  66
  67 static int
  68 parse_uint(uint64_t *value, const char *str)
  69 {
  70         char *next = NULL;
  71         uint64_t n;
  72
  73         errno = 0;
  74         /* Parse number string */
  75         n = strtol(str, &next, 10);
  76         if (errno != 0 || str == next || *next != '\0')
  77                 return -1;
  78
  79         *value = n;
  80
  81         return 0;
  82 }
  83
  84 static int
  85 parse_dscp_table_entries(char *str, enum rte_color **dscp_table)
  86 {
  87         char *token;
  88         int i = 0;
  89
  90         token = strtok_r(str, PARSE_DELIMITER, &str);
  91         if (token == NULL)
  92                 return 0;
  93
  94         /* Allocate memory for dscp table */
  95         *dscp_table = (enum rte_color *)malloc(MAX_DSCP_TABLE_ENTRIES *
  96                 sizeof(enum rte_color));
  97         if (*dscp_table == NULL)
  98                 return -1;
  99
 100         while (1) {
 101                 if (strcmp(token, "G") == 0 ||
 102                         strcmp(token, "g") == 0)
 103                         *dscp_table[i++] = RTE_COLOR_GREEN;
 104                 else if (strcmp(token, "Y") == 0 ||
 105                         strcmp(token, "y") == 0)
 106                         *dscp_table[i++] = RTE_COLOR_YELLOW;
 107                 else if (strcmp(token, "R") == 0 ||
 108                         strcmp(token, "r") == 0)
 109                         *dscp_table[i++] = RTE_COLOR_RED;
 110                 else {
 111                         free(*dscp_table);
 112                         return -1;
 113                 }
 114                 if (i == MAX_DSCP_TABLE_ENTRIES)
 115                         break;
 116
 117                 token = strtok_r(str, PARSE_DELIMITER, &str);
 118                 if (token == NULL) {
 119                         free(*dscp_table);
 120                         return -1;
 121                 }
 122         }
 123         return 0;
 124 }
 125
 126 static int
 127 parse_meter_color_str(char *c_str, uint32_t *use_prev_meter_color,
 128         enum rte_color **dscp_table)
 129 {
 130         char *token;
 131         uint64_t previous_mtr_color = 0;
 132         int ret;
 133
 134         /* First token: use previous meter color */
 135         token = strtok_r(c_str, PARSE_DELIMITER, &c_str);
 136         if (token ==  NULL)
 137                 return -1;
 138
 139         ret = parse_uint(&previous_mtr_color, token);
 140         if (ret != 0)
 141                 return -1;
 142
 143         /* Check if previous meter color to be used */
 144         if (previous_mtr_color) {
 145                 *use_prev_meter_color = previous_mtr_color;
 146                 return 0;
 147         }
 148
 149         /* Parse dscp table entries */
 150         ret = parse_dscp_table_entries(c_str, dscp_table);
 151         if (ret != 0)
 152                 return -1;
 153
 154         return 0;
 155 }
 156
 157 static int
 158 parse_multi_token_string(char *t_str, uint16_t *port_id,
 159         uint32_t *mtr_id, enum rte_color **dscp_table)
 160 {
 161         char *token;
 162         uint64_t val;
 163         int ret;
 164
 165         /* First token: port id */
 166         token = strtok_r(t_str, PARSE_DELIMITER, &t_str);
 167         if (token ==  NULL)
 168                 return -1;
 169
 170         ret = parse_uint(&val, token);
 171         if (ret != 0 || val > UINT16_MAX)
 172                 return -1;
 173
 174         *port_id = val;
 175
 176         /* Second token: meter id */
 177         token = strtok_r(t_str, PARSE_DELIMITER, &t_str);
 178         if (token == NULL)
 179                 return 0;
 180
 181         ret = parse_uint(&val, token);
 182         if (ret != 0 || val > UINT32_MAX)
 183                 return -1;
 184
 185         *mtr_id = val;
 186
 187         ret = parse_dscp_table_entries(t_str, dscp_table);
 188         if (ret != 0)
 189                 return -1;
 190
 191         return 0;
 192 }
 193
 194 /* *** Show Port Meter Capabilities *** */
 195 struct cmd_show_port_meter_cap_result {
 196         cmdline_fixed_string_t show;
 197         cmdline_fixed_string_t port;
 198         cmdline_fixed_string_t meter;
 199         cmdline_fixed_string_t cap;
 200         uint16_t port_id;
 201 };
 202
 203 cmdline_parse_token_string_t cmd_show_port_meter_cap_show =
 204         TOKEN_STRING_INITIALIZER(
 205                 struct cmd_show_port_meter_cap_result, show, "show");
 206 cmdline_parse_token_string_t cmd_show_port_meter_cap_port =
 207         TOKEN_STRING_INITIALIZER(
 208                 struct cmd_show_port_meter_cap_result, port, "port");
 209 cmdline_parse_token_string_t cmd_show_port_meter_cap_meter =
 210         TOKEN_STRING_INITIALIZER(
 211                 struct cmd_show_port_meter_cap_result, meter, "meter");
 212 cmdline_parse_token_string_t cmd_show_port_meter_cap_cap =
 213         TOKEN_STRING_INITIALIZER(
 214                 struct cmd_show_port_meter_cap_result, cap, "cap");
 215 cmdline_parse_token_num_t cmd_show_port_meter_cap_port_id =
 216         TOKEN_NUM_INITIALIZER(
 217                 struct cmd_show_port_meter_cap_result, port_id, RTE_UINT16);
 218
 219 static void cmd_show_port_meter_cap_parsed(void *parsed_result,
 220         __rte_unused struct cmdline *cl,
 221         __rte_unused void *data)
 222 {
 223         struct cmd_show_port_meter_cap_result *res = parsed_result;
 224         struct rte_mtr_capabilities cap;
 225         struct rte_mtr_error error;
 226         uint16_t port_id = res->port_id;
 227         int ret;
 228
 229         if (port_id_is_invalid(port_id, ENABLED_WARN))
 230                 return;
 231
 232         memset(&cap, 0, sizeof(struct rte_mtr_capabilities));
 233         ret = rte_mtr_capabilities_get(port_id, &cap, &error);
 234         if (ret) {
 235                 print_err_msg(&error);
 236                 return;
 237         }
 238
 239         printf("\n****   Port Meter Object Capabilities ****\n\n");
 240         printf("cap.n_max %" PRIu32 "\n", cap.n_max);
 241         printf("cap.n_shared_max %" PRIu32 "\n", cap.n_shared_max);
 242         printf("cap.identical %" PRId32 "\n", cap.identical);
 243         printf("cap.shared_identical %" PRId32 "\n",
 244                 cap.shared_identical);
 245         printf("cap.shared_n_flows_per_mtr_max %" PRIu32 "\n",
 246                 cap.shared_n_flows_per_mtr_max);
 247         printf("cap.chaining_n_mtrs_per_flow_max %" PRIu32 "\n",
 248                 cap.chaining_n_mtrs_per_flow_max);
 249         printf("cap.chaining_use_prev_mtr_color_supported %" PRId32 "\n",
 250                 cap.chaining_use_prev_mtr_color_supported);
 251         printf("cap.chaining_use_prev_mtr_color_enforced %" PRId32 "\n",
 252                 cap.chaining_use_prev_mtr_color_enforced);
 253         printf("cap.meter_srtcm_rfc2697_n_max %" PRIu32 "\n",
 254                 cap.meter_srtcm_rfc2697_n_max);
 255         printf("cap.meter_trtcm_rfc2698_n_max %" PRIu32 "\n",
 256                 cap.meter_trtcm_rfc2698_n_max);
 257         printf("cap.meter_trtcm_rfc4115_n_max %" PRIu32 "\n",
 258                 cap.meter_trtcm_rfc4115_n_max);
 259         printf("cap.meter_rate_max %" PRIu64 "\n", cap.meter_rate_max);
 260         printf("cap.color_aware_srtcm_rfc2697_supported %" PRId32 "\n",
 261                 cap.color_aware_srtcm_rfc2697_supported);
 262         printf("cap.color_aware_trtcm_rfc2698_supported %" PRId32 "\n",
 263                 cap.color_aware_trtcm_rfc2698_supported);
 264         printf("cap.color_aware_trtcm_rfc4115_supported %" PRId32 "\n",
 265                 cap.color_aware_trtcm_rfc4115_supported);
 266         printf("cap.srtcm_rfc2697_byte_mode_supported %" PRId32 "\n",
 267                 cap.srtcm_rfc2697_byte_mode_supported);
 268         printf("cap.srtcm_rfc2697_packet_mode_supported %" PRId32 "\n",
 269                 cap.srtcm_rfc2697_packet_mode_supported);
 270         printf("cap.trtcm_rfc2698_byte_mode_supported %" PRId32 "\n",
 271                 cap.trtcm_rfc2698_byte_mode_supported);
 272         printf("cap.trtcm_rfc2698_packet_mode_supported %" PRId32 "\n",
 273                 cap.trtcm_rfc2698_packet_mode_supported);
 274         printf("cap.trtcm_rfc4115_byte_mode_supported %" PRId32 "\n",
 275                 cap.trtcm_rfc4115_byte_mode_supported);
 276         printf("cap.trtcm_rfc4115_packet_mode_supported %" PRId32 "\n",
 277                 cap.trtcm_rfc4115_packet_mode_supported);
 278         printf("cap.stats_mask %" PRIx64 "\n", cap.stats_mask);
 279 }
 280
 281 cmdline_parse_inst_t cmd_show_port_meter_cap = {
 282         .f = cmd_show_port_meter_cap_parsed,
 283         .data = NULL,
 284         .help_str = "show port meter cap <port_id>",
 285         .tokens = {
 286                 (void *)&cmd_show_port_meter_cap_show,
 287                 (void *)&cmd_show_port_meter_cap_port,
 288                 (void *)&cmd_show_port_meter_cap_meter,
 289                 (void *)&cmd_show_port_meter_cap_cap,
 290                 (void *)&cmd_show_port_meter_cap_port_id,
 291                 NULL,
 292         },
 293 };
 294
 295 /* *** Add Port Meter Profile srtcm_rfc2697 *** */
 296 struct cmd_add_port_meter_profile_srtcm_result {
 297         cmdline_fixed_string_t add;
 298         cmdline_fixed_string_t port;
 299         cmdline_fixed_string_t meter;
 300         cmdline_fixed_string_t profile;
 301         cmdline_fixed_string_t srtcm_rfc2697;
 302         uint16_t port_id;
 303         uint32_t profile_id;
 304         uint64_t cir;
 305         uint64_t cbs;
 306         uint64_t ebs;
 307         int packet_mode;
 308 };
 309
 310 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_add =
 311         TOKEN_STRING_INITIALIZER(
 312                 struct cmd_add_port_meter_profile_srtcm_result, add, "add");
 313 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_port =
 314         TOKEN_STRING_INITIALIZER(
 315                 struct cmd_add_port_meter_profile_srtcm_result,
 316                         port, "port");
 317 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_meter =
 318         TOKEN_STRING_INITIALIZER(
 319                 struct cmd_add_port_meter_profile_srtcm_result,
 320                         meter, "meter");
 321 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_profile =
 322         TOKEN_STRING_INITIALIZER(
 323                 struct cmd_add_port_meter_profile_srtcm_result,
 324                         profile, "profile");
 325 cmdline_parse_token_string_t cmd_add_port_meter_profile_srtcm_srtcm_rfc2697 =
 326         TOKEN_STRING_INITIALIZER(
 327                 struct cmd_add_port_meter_profile_srtcm_result,
 328                         srtcm_rfc2697, "srtcm_rfc2697");
 329 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_port_id =
 330         TOKEN_NUM_INITIALIZER(
 331                 struct cmd_add_port_meter_profile_srtcm_result,
 332                         port_id, RTE_UINT16);
 333 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_profile_id =
 334         TOKEN_NUM_INITIALIZER(
 335                 struct cmd_add_port_meter_profile_srtcm_result,
 336                         profile_id, RTE_UINT32);
 337 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cir =
 338         TOKEN_NUM_INITIALIZER(
 339                 struct cmd_add_port_meter_profile_srtcm_result,
 340                         cir, RTE_UINT64);
 341 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_cbs =
 342         TOKEN_NUM_INITIALIZER(
 343                 struct cmd_add_port_meter_profile_srtcm_result,
 344                         cbs, RTE_UINT64);
 345 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_ebs =
 346         TOKEN_NUM_INITIALIZER(
 347                 struct cmd_add_port_meter_profile_srtcm_result,
 348                         ebs, RTE_UINT64);
 349 cmdline_parse_token_num_t cmd_add_port_meter_profile_srtcm_packet_mode =
 350         TOKEN_NUM_INITIALIZER(
 351                 struct cmd_add_port_meter_profile_srtcm_result,
 352                         packet_mode, RTE_UINT32);
 353
 354 static void cmd_add_port_meter_profile_srtcm_parsed(void *parsed_result,
 355         __rte_unused struct cmdline *cl,
 356         __rte_unused void *data)
 357 {
 358         struct cmd_add_port_meter_profile_srtcm_result *res = parsed_result;
 359         struct rte_mtr_meter_profile mp;
 360         struct rte_mtr_error error;
 361         uint32_t profile_id = res->profile_id;
 362         uint16_t port_id = res->port_id;
 363         int ret;
 364
 365         if (port_id_is_invalid(port_id, ENABLED_WARN))
 366                 return;
 367
 368         /* Private shaper profile params */
 369         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
 370         mp.alg = RTE_MTR_SRTCM_RFC2697;
 371         mp.srtcm_rfc2697.cir = res->cir;
 372         mp.srtcm_rfc2697.cbs = res->cbs;
 373         mp.srtcm_rfc2697.ebs = res->ebs;
 374         mp.packet_mode = res->packet_mode;
 375
 376         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
 377         if (ret != 0) {
 378                 print_err_msg(&error);
 379                 return;
 380         }
 381 }
 382
 383 cmdline_parse_inst_t cmd_add_port_meter_profile_srtcm = {
 384         .f = cmd_add_port_meter_profile_srtcm_parsed,
 385         .data = NULL,
 386         .help_str = "add port meter profile srtcm_rfc2697 <port_id> <profile_id> <cir> <cbs> <ebs> <packet_mode>",
 387         .tokens = {
 388                 (void *)&cmd_add_port_meter_profile_srtcm_add,
 389                 (void *)&cmd_add_port_meter_profile_srtcm_port,
 390                 (void *)&cmd_add_port_meter_profile_srtcm_meter,
 391                 (void *)&cmd_add_port_meter_profile_srtcm_profile,
 392                 (void *)&cmd_add_port_meter_profile_srtcm_srtcm_rfc2697,
 393                 (void *)&cmd_add_port_meter_profile_srtcm_port_id,
 394                 (void *)&cmd_add_port_meter_profile_srtcm_profile_id,
 395                 (void *)&cmd_add_port_meter_profile_srtcm_cir,
 396                 (void *)&cmd_add_port_meter_profile_srtcm_cbs,
 397                 (void *)&cmd_add_port_meter_profile_srtcm_ebs,
 398                 (void *)&cmd_add_port_meter_profile_srtcm_packet_mode,
 399                 NULL,
 400         },
 401 };
 402
 403 /* *** Add Port Meter Profile trtcm_rfc2698 *** */
 404 struct cmd_add_port_meter_profile_trtcm_result {
 405         cmdline_fixed_string_t add;
 406         cmdline_fixed_string_t port;
 407         cmdline_fixed_string_t meter;
 408         cmdline_fixed_string_t profile;
 409         cmdline_fixed_string_t trtcm_rfc2698;
 410         uint16_t port_id;
 411         uint32_t profile_id;
 412         uint64_t cir;
 413         uint64_t pir;
 414         uint64_t cbs;
 415         uint64_t pbs;
 416         int packet_mode;
 417 };
 418
 419 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_add =
 420         TOKEN_STRING_INITIALIZER(
 421                 struct cmd_add_port_meter_profile_trtcm_result, add, "add");
 422 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_port =
 423         TOKEN_STRING_INITIALIZER(
 424                 struct cmd_add_port_meter_profile_trtcm_result,
 425                         port, "port");
 426 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_meter =
 427         TOKEN_STRING_INITIALIZER(
 428                 struct cmd_add_port_meter_profile_trtcm_result,
 429                         meter, "meter");
 430 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_profile =
 431         TOKEN_STRING_INITIALIZER(
 432                 struct cmd_add_port_meter_profile_trtcm_result,
 433                         profile, "profile");
 434 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_trtcm_rfc2698 =
 435         TOKEN_STRING_INITIALIZER(
 436                 struct cmd_add_port_meter_profile_trtcm_result,
 437                         trtcm_rfc2698, "trtcm_rfc2698");
 438 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_port_id =
 439         TOKEN_NUM_INITIALIZER(
 440                 struct cmd_add_port_meter_profile_trtcm_result,
 441                         port_id, RTE_UINT16);
 442 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_profile_id =
 443         TOKEN_NUM_INITIALIZER(
 444                 struct cmd_add_port_meter_profile_trtcm_result,
 445                         profile_id, RTE_UINT32);
 446 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cir =
 447         TOKEN_NUM_INITIALIZER(
 448                 struct cmd_add_port_meter_profile_trtcm_result,
 449                         cir, RTE_UINT64);
 450 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pir =
 451         TOKEN_NUM_INITIALIZER(
 452                 struct cmd_add_port_meter_profile_trtcm_result,
 453                         pir, RTE_UINT64);
 454 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_cbs =
 455         TOKEN_NUM_INITIALIZER(
 456                 struct cmd_add_port_meter_profile_trtcm_result,
 457                         cbs, RTE_UINT64);
 458 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_pbs =
 459         TOKEN_NUM_INITIALIZER(
 460                 struct cmd_add_port_meter_profile_trtcm_result,
 461                         pbs, RTE_UINT64);
 462 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_packet_mode =
 463         TOKEN_NUM_INITIALIZER(
 464                 struct cmd_add_port_meter_profile_trtcm_result,
 465                         packet_mode, RTE_UINT32);
 466
 467 static void cmd_add_port_meter_profile_trtcm_parsed(void *parsed_result,
 468         __rte_unused struct cmdline *cl,
 469         __rte_unused void *data)
 470 {
 471         struct cmd_add_port_meter_profile_trtcm_result *res = parsed_result;
 472         struct rte_mtr_meter_profile mp;
 473         struct rte_mtr_error error;
 474         uint32_t profile_id = res->profile_id;
 475         uint16_t port_id = res->port_id;
 476         int ret;
 477
 478         if (port_id_is_invalid(port_id, ENABLED_WARN))
 479                 return;
 480
 481         /* Private shaper profile params */
 482         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
 483         mp.alg = RTE_MTR_TRTCM_RFC2698;
 484         mp.trtcm_rfc2698.cir = res->cir;
 485         mp.trtcm_rfc2698.pir = res->pir;
 486         mp.trtcm_rfc2698.cbs = res->cbs;
 487         mp.trtcm_rfc2698.pbs = res->pbs;
 488         mp.packet_mode = res->packet_mode;
 489
 490         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
 491         if (ret != 0) {
 492                 print_err_msg(&error);
 493                 return;
 494         }
 495 }
 496
 497 cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm = {
 498         .f = cmd_add_port_meter_profile_trtcm_parsed,
 499         .data = NULL,
 500         .help_str = "add port meter profile trtcm_rfc2698 <port_id> <profile_id> <cir> <pir> <cbs> <pbs> <packet_mode>",
 501         .tokens = {
 502                 (void *)&cmd_add_port_meter_profile_trtcm_add,
 503                 (void *)&cmd_add_port_meter_profile_trtcm_port,
 504                 (void *)&cmd_add_port_meter_profile_trtcm_meter,
 505                 (void *)&cmd_add_port_meter_profile_trtcm_profile,
 506                 (void *)&cmd_add_port_meter_profile_trtcm_trtcm_rfc2698,
 507                 (void *)&cmd_add_port_meter_profile_trtcm_port_id,
 508                 (void *)&cmd_add_port_meter_profile_trtcm_profile_id,
 509                 (void *)&cmd_add_port_meter_profile_trtcm_cir,
 510                 (void *)&cmd_add_port_meter_profile_trtcm_pir,
 511                 (void *)&cmd_add_port_meter_profile_trtcm_cbs,
 512                 (void *)&cmd_add_port_meter_profile_trtcm_pbs,
 513                 (void *)&cmd_add_port_meter_profile_trtcm_packet_mode,
 514                 NULL,
 515         },
 516 };
 517
 518 /* *** Add Port Meter Profile trtcm_rfc4115 *** */
 519 struct cmd_add_port_meter_profile_trtcm_rfc4115_result {
 520         cmdline_fixed_string_t add;
 521         cmdline_fixed_string_t port;
 522         cmdline_fixed_string_t meter;
 523         cmdline_fixed_string_t profile;
 524         cmdline_fixed_string_t trtcm_rfc4115;
 525         uint16_t port_id;
 526         uint32_t profile_id;
 527         uint64_t cir;
 528         uint64_t eir;
 529         uint64_t cbs;
 530         uint64_t ebs;
 531         int packet_mode;
 532 };
 533
 534 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_add =
 535         TOKEN_STRING_INITIALIZER(
 536                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result, add,
 537                 "add");
 538 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_port =
 539         TOKEN_STRING_INITIALIZER(
 540                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 541                         port, "port");
 542 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_meter =
 543         TOKEN_STRING_INITIALIZER(
 544                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 545                         meter, "meter");
 546 cmdline_parse_token_string_t cmd_add_port_meter_profile_trtcm_rfc4115_profile =
 547         TOKEN_STRING_INITIALIZER(
 548                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 549                         profile, "profile");
 550 cmdline_parse_token_string_t
 551         cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115 =
 552         TOKEN_STRING_INITIALIZER(
 553                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 554                         trtcm_rfc4115, "trtcm_rfc4115");
 555 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_port_id =
 556         TOKEN_NUM_INITIALIZER(
 557                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 558                         port_id, RTE_UINT16);
 559 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_profile_id =
 560         TOKEN_NUM_INITIALIZER(
 561                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 562                         profile_id, RTE_UINT32);
 563 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cir =
 564         TOKEN_NUM_INITIALIZER(
 565                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 566                         cir, RTE_UINT64);
 567 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_eir =
 568         TOKEN_NUM_INITIALIZER(
 569                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 570                         eir, RTE_UINT64);
 571 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_cbs =
 572         TOKEN_NUM_INITIALIZER(
 573                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 574                         cbs, RTE_UINT64);
 575 cmdline_parse_token_num_t cmd_add_port_meter_profile_trtcm_rfc4115_ebs =
 576         TOKEN_NUM_INITIALIZER(
 577                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 578                         ebs, RTE_UINT64);
 579 cmdline_parse_token_num_t
 580         cmd_add_port_meter_profile_trtcm_rfc4115_packet_mode =
 581         TOKEN_NUM_INITIALIZER(
 582                 struct cmd_add_port_meter_profile_trtcm_rfc4115_result,
 583                         packet_mode, RTE_UINT32);
 584
 585 static void cmd_add_port_meter_profile_trtcm_rfc4115_parsed(
 586         void *parsed_result,
 587         __rte_unused struct cmdline *cl,
 588         __rte_unused void *data)
 589 {
 590         struct cmd_add_port_meter_profile_trtcm_rfc4115_result *res =
 591                 parsed_result;
 592         struct rte_mtr_meter_profile mp;
 593         struct rte_mtr_error error;
 594         uint32_t profile_id = res->profile_id;
 595         uint16_t port_id = res->port_id;
 596         int ret;
 597
 598         if (port_id_is_invalid(port_id, ENABLED_WARN))
 599                 return;
 600
 601         /* Private shaper profile params */
 602         memset(&mp, 0, sizeof(struct rte_mtr_meter_profile));
 603         mp.alg = RTE_MTR_TRTCM_RFC4115;
 604         mp.trtcm_rfc4115.cir = res->cir;
 605         mp.trtcm_rfc4115.eir = res->eir;
 606         mp.trtcm_rfc4115.cbs = res->cbs;
 607         mp.trtcm_rfc4115.ebs = res->ebs;
 608         mp.packet_mode = res->packet_mode;
 609
 610         ret = rte_mtr_meter_profile_add(port_id, profile_id, &mp, &error);
 611         if (ret != 0) {
 612                 print_err_msg(&error);
 613                 return;
 614         }
 615 }
 616
 617 cmdline_parse_inst_t cmd_add_port_meter_profile_trtcm_rfc4115 = {
 618         .f = cmd_add_port_meter_profile_trtcm_rfc4115_parsed,
 619         .data = NULL,
 620         .help_str = "add port meter profile trtcm_rfc4115 <port_id> <profile_id> <cir> <eir> <cbs> <ebs> <packet_mode>",
 621         .tokens = {
 622                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_add,
 623                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port,
 624                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_meter,
 625                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile,
 626                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_trtcm_rfc4115,
 627                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_port_id,
 628                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_profile_id,
 629                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cir,
 630                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_eir,
 631                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_cbs,
 632                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_ebs,
 633                 (void *)&cmd_add_port_meter_profile_trtcm_rfc4115_packet_mode,
 634                 NULL,
 635         },
 636 };
 637
 638 /* *** Delete Port Meter Profile *** */
 639 struct cmd_del_port_meter_profile_result {
 640         cmdline_fixed_string_t del;
 641         cmdline_fixed_string_t port;
 642         cmdline_fixed_string_t meter;
 643         cmdline_fixed_string_t profile;
 644         uint16_t port_id;
 645         uint32_t profile_id;
 646 };
 647
 648 cmdline_parse_token_string_t cmd_del_port_meter_profile_del =
 649         TOKEN_STRING_INITIALIZER(
 650                 struct cmd_del_port_meter_profile_result, del, "del");
 651 cmdline_parse_token_string_t cmd_del_port_meter_profile_port =
 652         TOKEN_STRING_INITIALIZER(
 653                 struct cmd_del_port_meter_profile_result,
 654                         port, "port");
 655 cmdline_parse_token_string_t cmd_del_port_meter_profile_meter =
 656         TOKEN_STRING_INITIALIZER(
 657                 struct cmd_del_port_meter_profile_result,
 658                         meter, "meter");
 659 cmdline_parse_token_string_t cmd_del_port_meter_profile_profile =
 660         TOKEN_STRING_INITIALIZER(
 661                 struct cmd_del_port_meter_profile_result,
 662                         profile, "profile");
 663 cmdline_parse_token_num_t cmd_del_port_meter_profile_port_id =
 664         TOKEN_NUM_INITIALIZER(
 665                 struct cmd_del_port_meter_profile_result,
 666                         port_id, RTE_UINT16);
 667 cmdline_parse_token_num_t cmd_del_port_meter_profile_profile_id =
 668         TOKEN_NUM_INITIALIZER(
 669                 struct cmd_del_port_meter_profile_result,
 670                         profile_id, RTE_UINT32);
 671
 672 static void cmd_del_port_meter_profile_parsed(void *parsed_result,
 673         __rte_unused struct cmdline *cl,
 674         __rte_unused void *data)
 675 {
 676         struct cmd_del_port_meter_profile_result *res = parsed_result;
 677         struct rte_mtr_error error;
 678         uint32_t profile_id = res->profile_id;
 679         uint16_t port_id = res->port_id;
 680         int ret;
 681
 682         if (port_id_is_invalid(port_id, ENABLED_WARN))
 683                 return;
 684
 685         /* Delete meter profile */
 686         ret = rte_mtr_meter_profile_delete(port_id, profile_id, &error);
 687         if (ret != 0) {
 688                 print_err_msg(&error);
 689                 return;
 690         }
 691 }
 692
 693 cmdline_parse_inst_t cmd_del_port_meter_profile = {
 694         .f = cmd_del_port_meter_profile_parsed,
 695         .data = NULL,
 696         .help_str = "del port meter profile <port_id> <profile_id>",
 697         .tokens = {
 698                 (void *)&cmd_del_port_meter_profile_del,
 699                 (void *)&cmd_del_port_meter_profile_port,
 700                 (void *)&cmd_del_port_meter_profile_meter,
 701                 (void *)&cmd_del_port_meter_profile_profile,
 702                 (void *)&cmd_del_port_meter_profile_port_id,
 703                 (void *)&cmd_del_port_meter_profile_profile_id,
 704                 NULL,
 705         },
 706 };
 707
 708 /* *** Create Port Meter Object *** */
 709 struct cmd_create_port_meter_result {
 710         cmdline_fixed_string_t create;
 711         cmdline_fixed_string_t port;
 712         cmdline_fixed_string_t meter;
 713         uint16_t port_id;
 714         uint32_t mtr_id;
 715         uint32_t profile_id;
 716         uint32_t policy_id;
 717         cmdline_fixed_string_t meter_enable;
 718         cmdline_fixed_string_t g_action;
 719         cmdline_fixed_string_t y_action;
 720         cmdline_fixed_string_t r_action;
 721         uint64_t statistics_mask;
 722         uint32_t shared;
 723         cmdline_multi_string_t meter_input_color;
 724 };
 725
 726 cmdline_parse_token_string_t cmd_create_port_meter_create =
 727         TOKEN_STRING_INITIALIZER(
 728                 struct cmd_create_port_meter_result, create, "create");
 729 cmdline_parse_token_string_t cmd_create_port_meter_port =
 730         TOKEN_STRING_INITIALIZER(
 731                 struct cmd_create_port_meter_result, port, "port");
 732 cmdline_parse_token_string_t cmd_create_port_meter_meter =
 733         TOKEN_STRING_INITIALIZER(
 734                 struct cmd_create_port_meter_result, meter, "meter");
 735 cmdline_parse_token_num_t cmd_create_port_meter_port_id =
 736         TOKEN_NUM_INITIALIZER(
 737                 struct cmd_create_port_meter_result, port_id, RTE_UINT16);
 738 cmdline_parse_token_num_t cmd_create_port_meter_mtr_id =
 739         TOKEN_NUM_INITIALIZER(
 740                 struct cmd_create_port_meter_result, mtr_id, RTE_UINT32);
 741 cmdline_parse_token_num_t cmd_create_port_meter_profile_id =
 742         TOKEN_NUM_INITIALIZER(
 743                 struct cmd_create_port_meter_result, profile_id, RTE_UINT32);
 744 cmdline_parse_token_num_t cmd_create_port_meter_policy_id =
 745         TOKEN_NUM_INITIALIZER(
 746                 struct cmd_create_port_meter_result, policy_id, RTE_UINT32);
 747 cmdline_parse_token_string_t cmd_create_port_meter_meter_enable =
 748         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
 749                 meter_enable, "yes#no");
 750 cmdline_parse_token_string_t cmd_create_port_meter_g_action =
 751         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
 752                 g_action, "R#Y#G#D#r#y#g#d");
 753 cmdline_parse_token_string_t cmd_create_port_meter_y_action =
 754         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
 755                 y_action, "R#Y#G#D#r#y#g#d");
 756 cmdline_parse_token_string_t cmd_create_port_meter_r_action =
 757         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
 758                 r_action, "R#Y#G#D#r#y#g#d");
 759 cmdline_parse_token_num_t cmd_create_port_meter_statistics_mask =
 760         TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
 761                 statistics_mask, RTE_UINT64);
 762 cmdline_parse_token_num_t cmd_create_port_meter_shared =
 763         TOKEN_NUM_INITIALIZER(struct cmd_create_port_meter_result,
 764                 shared, RTE_UINT32);
 765 cmdline_parse_token_string_t cmd_create_port_meter_input_color =
 766         TOKEN_STRING_INITIALIZER(struct cmd_create_port_meter_result,
 767                 meter_input_color, TOKEN_STRING_MULTI);
 768
 769 static void cmd_create_port_meter_parsed(void *parsed_result,
 770         __rte_unused struct cmdline *cl,
 771         __rte_unused void *data)
 772 {
 773         struct cmd_create_port_meter_result *res = parsed_result;
 774         struct rte_mtr_error error;
 775         struct rte_mtr_params params;
 776         uint32_t mtr_id = res->mtr_id;
 777         uint32_t shared = res->shared;
 778         uint32_t use_prev_meter_color = 0;
 779         uint16_t port_id = res->port_id;
 780         enum rte_color *dscp_table = NULL;
 781         char *c_str = res->meter_input_color;
 782         int ret;
 783
 784         if (port_id_is_invalid(port_id, ENABLED_WARN))
 785                 return;
 786
 787         /* Meter params */
 788         memset(&params, 0, sizeof(struct rte_mtr_params));
 789         params.meter_profile_id = res->profile_id;
 790         params.meter_policy_id = res->policy_id;
 791         /* Parse meter input color string params */
 792         ret = parse_meter_color_str(c_str, &use_prev_meter_color, &dscp_table);
 793         if (ret) {
 794                 printf(" Meter input color params string parse error\n");
 795                 return;
 796         }
 797
 798         params.use_prev_mtr_color = use_prev_meter_color;
 799         params.dscp_table = dscp_table;
 800
 801         if (strcmp(res->meter_enable, "yes") == 0)
 802                 params.meter_enable = 1;
 803         else
 804                 params.meter_enable = 0;
 805         params.stats_mask = res->statistics_mask;
 806
 807         ret = rte_mtr_create(port_id, mtr_id, &params, shared, &error);
 808         if (ret != 0) {
 809                 free(dscp_table);
 810                 print_err_msg(&error);
 811                 return;
 812         }
 813 }
 814
 815 cmdline_parse_inst_t cmd_create_port_meter = {
 816         .f = cmd_create_port_meter_parsed,
 817         .data = NULL,
 818         .help_str = "create port meter <port_id> <mtr_id> <profile_id> <meter_enable>(yes|no) "
 819                 "<stats_mask> <shared> <use_pre_meter_color> "
 820                 "[<dscp_tbl_entry0> <dscp_tbl_entry1> ...<dscp_tbl_entry63>]",
 821         .tokens = {
 822                 (void *)&cmd_create_port_meter_create,
 823                 (void *)&cmd_create_port_meter_port,
 824                 (void *)&cmd_create_port_meter_meter,
 825                 (void *)&cmd_create_port_meter_port_id,
 826                 (void *)&cmd_create_port_meter_mtr_id,
 827                 (void *)&cmd_create_port_meter_profile_id,
 828                 (void *)&cmd_create_port_meter_policy_id,
 829                 (void *)&cmd_create_port_meter_meter_enable,
 830                 (void *)&cmd_create_port_meter_statistics_mask,
 831                 (void *)&cmd_create_port_meter_shared,
 832                 (void *)&cmd_create_port_meter_input_color,
 833                 NULL,
 834         },
 835 };
 836
 837 /* *** Enable Meter of MTR Object  *** */
 838 struct cmd_enable_port_meter_result {
 839         cmdline_fixed_string_t enable;
 840         cmdline_fixed_string_t port;
 841         cmdline_fixed_string_t meter;
 842         uint16_t port_id;
 843         uint32_t mtr_id;
 844 };
 845
 846 cmdline_parse_token_string_t cmd_enable_port_meter_enable =
 847         TOKEN_STRING_INITIALIZER(
 848                 struct cmd_enable_port_meter_result, enable, "enable");
 849 cmdline_parse_token_string_t cmd_enable_port_meter_port =
 850         TOKEN_STRING_INITIALIZER(
 851                 struct cmd_enable_port_meter_result, port, "port");
 852 cmdline_parse_token_string_t cmd_enable_port_meter_meter =
 853         TOKEN_STRING_INITIALIZER(
 854                 struct cmd_enable_port_meter_result, meter, "meter");
 855 cmdline_parse_token_num_t cmd_enable_port_meter_port_id =
 856         TOKEN_NUM_INITIALIZER(
 857                 struct cmd_enable_port_meter_result, port_id, RTE_UINT16);
 858 cmdline_parse_token_num_t cmd_enable_port_meter_mtr_id =
 859         TOKEN_NUM_INITIALIZER(
 860                 struct cmd_enable_port_meter_result, mtr_id, RTE_UINT32);
 861
 862 static void cmd_enable_port_meter_parsed(void *parsed_result,
 863         __rte_unused struct cmdline *cl,
 864         __rte_unused void *data)
 865 {
 866         struct cmd_enable_port_meter_result *res = parsed_result;
 867         struct rte_mtr_error error;
 868         uint32_t mtr_id = res->mtr_id;
 869         uint16_t port_id = res->port_id;
 870
 871         int ret;
 872
 873         if (port_id_is_invalid(port_id, ENABLED_WARN))
 874                 return;
 875
 876         /* Enable Meter */
 877         ret = rte_mtr_meter_enable(port_id, mtr_id, &error);
 878         if (ret != 0) {
 879                 print_err_msg(&error);
 880                 return;
 881         }
 882 }
 883
 884 cmdline_parse_inst_t cmd_enable_port_meter = {
 885         .f = cmd_enable_port_meter_parsed,
 886         .data = NULL,
 887         .help_str = "enable port meter <port_id> <mtr_id>",
 888         .tokens = {
 889                 (void *)&cmd_enable_port_meter_enable,
 890                 (void *)&cmd_enable_port_meter_port,
 891                 (void *)&cmd_enable_port_meter_meter,
 892                 (void *)&cmd_enable_port_meter_port_id,
 893                 (void *)&cmd_enable_port_meter_mtr_id,
 894                 NULL,
 895         },
 896 };
 897
 898 /* *** Disable Meter of MTR Object  *** */
 899 struct cmd_disable_port_meter_result {
 900         cmdline_fixed_string_t disable;
 901         cmdline_fixed_string_t port;
 902         cmdline_fixed_string_t meter;
 903         uint16_t port_id;
 904         uint32_t mtr_id;
 905 };
 906
 907 cmdline_parse_token_string_t cmd_disable_port_meter_disable =
 908         TOKEN_STRING_INITIALIZER(
 909                 struct cmd_disable_port_meter_result, disable, "disable");
 910 cmdline_parse_token_string_t cmd_disable_port_meter_port =
 911         TOKEN_STRING_INITIALIZER(
 912                 struct cmd_disable_port_meter_result, port, "port");
 913 cmdline_parse_token_string_t cmd_disable_port_meter_meter =
 914         TOKEN_STRING_INITIALIZER(
 915                 struct cmd_disable_port_meter_result, meter, "meter");
 916 cmdline_parse_token_num_t cmd_disable_port_meter_port_id =
 917         TOKEN_NUM_INITIALIZER(
 918                 struct cmd_disable_port_meter_result, port_id, RTE_UINT16);
 919 cmdline_parse_token_num_t cmd_disable_port_meter_mtr_id =
 920         TOKEN_NUM_INITIALIZER(
 921                 struct cmd_disable_port_meter_result, mtr_id, RTE_UINT32);
 922
 923 static void cmd_disable_port_meter_parsed(void *parsed_result,
 924         __rte_unused struct cmdline *cl,
 925         __rte_unused void *data)
 926 {
 927         struct cmd_disable_port_meter_result *res = parsed_result;
 928         struct rte_mtr_error error;
 929         uint32_t mtr_id = res->mtr_id;
 930         uint16_t port_id = res->port_id;
 931
 932         int ret;
 933
 934         if (port_id_is_invalid(port_id, ENABLED_WARN))
 935                 return;
 936
 937         /* Disable Meter */
 938         ret = rte_mtr_meter_disable(port_id, mtr_id, &error);
 939         if (ret != 0) {
 940                 print_err_msg(&error);
 941                 return;
 942         }
 943 }
 944
 945 cmdline_parse_inst_t cmd_disable_port_meter = {
 946         .f = cmd_disable_port_meter_parsed,
 947         .data = NULL,
 948         .help_str = "disable port meter <port_id> <mtr_id>",
 949         .tokens = {
 950                 (void *)&cmd_disable_port_meter_disable,
 951                 (void *)&cmd_disable_port_meter_port,
 952                 (void *)&cmd_disable_port_meter_meter,
 953                 (void *)&cmd_disable_port_meter_port_id,
 954                 (void *)&cmd_disable_port_meter_mtr_id,
 955                 NULL,
 956         },
 957 };
 958
 959 /* *** Delete Port Meter Policy Object *** */
 960 struct cmd_del_port_meter_policy_result {
 961         cmdline_fixed_string_t del;
 962         cmdline_fixed_string_t port;
 963         cmdline_fixed_string_t meter;
 964         cmdline_fixed_string_t policy;
 965         uint16_t port_id;
 966         uint32_t policy_id;
 967 };
 968
 969 cmdline_parse_token_string_t cmd_del_port_meter_policy_del =
 970         TOKEN_STRING_INITIALIZER(
 971                 struct cmd_del_port_meter_policy_result, del, "del");
 972 cmdline_parse_token_string_t cmd_del_port_meter_policy_port =
 973         TOKEN_STRING_INITIALIZER(
 974                 struct cmd_del_port_meter_policy_result, port, "port");
 975 cmdline_parse_token_string_t cmd_del_port_meter_policy_meter =
 976         TOKEN_STRING_INITIALIZER(
 977                 struct cmd_del_port_meter_policy_result, meter, "meter");
 978 cmdline_parse_token_string_t cmd_del_port_meter_policy_policy =
 979         TOKEN_STRING_INITIALIZER(
 980                 struct cmd_del_port_meter_policy_result, policy, "policy");
 981 cmdline_parse_token_num_t cmd_del_port_meter_policy_port_id =
 982         TOKEN_NUM_INITIALIZER(
 983                 struct cmd_del_port_meter_policy_result, port_id, RTE_UINT16);
 984 cmdline_parse_token_num_t cmd_del_port_meter_policy_policy_id =
 985         TOKEN_NUM_INITIALIZER(
 986                 struct cmd_del_port_meter_policy_result, policy_id, RTE_UINT32);
 987
 988 static void cmd_del_port_meter_policy_parsed(void *parsed_result,
 989         __rte_unused struct cmdline *cl,
 990         __rte_unused void *data)
 991 {
 992         struct cmd_del_port_meter_policy_result *res = parsed_result;
 993         struct rte_mtr_error error;
 994         uint32_t policy_id = res->policy_id;
 995         uint16_t port_id = res->port_id;
 996         int ret;
 997
 998         if (port_id_is_invalid(port_id, ENABLED_WARN))
 999                 return;
1000
1001         /* Delete Meter Policy*/
1002         ret = rte_mtr_meter_policy_delete(port_id, policy_id, &error);
1003         if (ret != 0) {
1004                 print_err_msg(&error);
1005                 return;
1006         }
1007 }
1008
1009 cmdline_parse_inst_t cmd_del_port_meter_policy = {
1010         .f = cmd_del_port_meter_policy_parsed,
1011         .data = NULL,
1012         .help_str = "Delete port meter policy",
1013         .tokens = {
1014                 (void *)&cmd_del_port_meter_policy_del,
1015                 (void *)&cmd_del_port_meter_policy_port,
1016                 (void *)&cmd_del_port_meter_policy_meter,
1017                 (void *)&cmd_del_port_meter_policy_policy,
1018                 (void *)&cmd_del_port_meter_policy_port_id,
1019                 (void *)&cmd_del_port_meter_policy_policy_id,
1020                 NULL,
1021         },
1022 };
1023
1024 /* *** Delete Port Meter Object *** */
1025 struct cmd_del_port_meter_result {
1026         cmdline_fixed_string_t del;
1027         cmdline_fixed_string_t port;
1028         cmdline_fixed_string_t meter;
1029         uint16_t port_id;
1030         uint32_t mtr_id;
1031 };
1032
1033 cmdline_parse_token_string_t cmd_del_port_meter_del =
1034         TOKEN_STRING_INITIALIZER(
1035                 struct cmd_del_port_meter_result, del, "del");
1036 cmdline_parse_token_string_t cmd_del_port_meter_port =
1037         TOKEN_STRING_INITIALIZER(
1038                 struct cmd_del_port_meter_result, port, "port");
1039 cmdline_parse_token_string_t cmd_del_port_meter_meter =
1040         TOKEN_STRING_INITIALIZER(
1041                 struct cmd_del_port_meter_result, meter, "meter");
1042 cmdline_parse_token_num_t cmd_del_port_meter_port_id =
1043         TOKEN_NUM_INITIALIZER(
1044                 struct cmd_del_port_meter_result, port_id, RTE_UINT16);
1045 cmdline_parse_token_num_t cmd_del_port_meter_mtr_id =
1046         TOKEN_NUM_INITIALIZER(
1047                 struct cmd_del_port_meter_result, mtr_id, RTE_UINT32);
1048
1049 static void cmd_del_port_meter_parsed(void *parsed_result,
1050         __rte_unused struct cmdline *cl,
1051         __rte_unused void *data)
1052 {
1053         struct cmd_del_port_meter_result *res = parsed_result;
1054         struct rte_mtr_error error;
1055         uint32_t mtr_id = res->mtr_id;
1056         uint16_t port_id = res->port_id;
1057
1058         int ret;
1059
1060         if (port_id_is_invalid(port_id, ENABLED_WARN))
1061                 return;
1062
1063         /* Destroy Meter */
1064         ret = rte_mtr_destroy(port_id, mtr_id, &error);
1065         if (ret != 0) {
1066                 print_err_msg(&error);
1067                 return;
1068         }
1069 }
1070
1071 cmdline_parse_inst_t cmd_del_port_meter = {
1072         .f = cmd_del_port_meter_parsed,
1073         .data = NULL,
1074         .help_str = "del port meter <port_id> <mtr_id>",
1075         .tokens = {
1076                 (void *)&cmd_del_port_meter_del,
1077                 (void *)&cmd_del_port_meter_port,
1078                 (void *)&cmd_del_port_meter_meter,
1079                 (void *)&cmd_del_port_meter_port_id,
1080                 (void *)&cmd_del_port_meter_mtr_id,
1081                 NULL,
1082         },
1083 };
1084
1085 /* *** Set Port Meter Profile *** */
1086 struct cmd_set_port_meter_profile_result {
1087         cmdline_fixed_string_t set;
1088         cmdline_fixed_string_t port;
1089         cmdline_fixed_string_t meter;
1090         cmdline_fixed_string_t profile;
1091         uint16_t port_id;
1092         uint32_t mtr_id;
1093         uint32_t profile_id;
1094 };
1095
1096 cmdline_parse_token_string_t cmd_set_port_meter_profile_set =
1097         TOKEN_STRING_INITIALIZER(
1098                 struct cmd_set_port_meter_profile_result, set, "set");
1099 cmdline_parse_token_string_t cmd_set_port_meter_profile_port =
1100         TOKEN_STRING_INITIALIZER(
1101                 struct cmd_set_port_meter_profile_result, port, "port");
1102 cmdline_parse_token_string_t cmd_set_port_meter_profile_meter =
1103         TOKEN_STRING_INITIALIZER(
1104                 struct cmd_set_port_meter_profile_result, meter, "meter");
1105 cmdline_parse_token_string_t cmd_set_port_meter_profile_profile =
1106         TOKEN_STRING_INITIALIZER(
1107                 struct cmd_set_port_meter_profile_result, profile, "profile");
1108 cmdline_parse_token_num_t cmd_set_port_meter_profile_port_id =
1109         TOKEN_NUM_INITIALIZER(
1110                 struct cmd_set_port_meter_profile_result, port_id,
1111                 RTE_UINT16);
1112 cmdline_parse_token_num_t cmd_set_port_meter_profile_mtr_id =
1113         TOKEN_NUM_INITIALIZER(
1114                 struct cmd_set_port_meter_profile_result, mtr_id,
1115                 RTE_UINT32);
1116 cmdline_parse_token_num_t cmd_set_port_meter_profile_profile_id =
1117         TOKEN_NUM_INITIALIZER(
1118                 struct cmd_set_port_meter_profile_result, profile_id,
1119                 RTE_UINT32);
1120
1121 static void cmd_set_port_meter_profile_parsed(void *parsed_result,
1122         __rte_unused struct cmdline *cl,
1123         __rte_unused void *data)
1124 {
1125         struct cmd_set_port_meter_profile_result *res = parsed_result;
1126         struct rte_mtr_error error;
1127         uint32_t mtr_id = res->mtr_id;
1128         uint32_t profile_id = res->profile_id;
1129         uint16_t port_id = res->port_id;
1130
1131         int ret;
1132
1133         if (port_id_is_invalid(port_id, ENABLED_WARN))
1134                 return;
1135
1136         /* Set meter profile */
1137         ret = rte_mtr_meter_profile_update(port_id, mtr_id,
1138                 profile_id, &error);
1139         if (ret != 0) {
1140                 print_err_msg(&error);
1141                 return;
1142         }
1143 }
1144
1145 cmdline_parse_inst_t cmd_set_port_meter_profile = {
1146         .f = cmd_set_port_meter_profile_parsed,
1147         .data = NULL,
1148         .help_str = "set port meter profile <port_id> <mtr_id> <profile_id>",
1149         .tokens = {
1150                 (void *)&cmd_set_port_meter_profile_set,
1151                 (void *)&cmd_set_port_meter_profile_port,
1152                 (void *)&cmd_set_port_meter_profile_meter,
1153                 (void *)&cmd_set_port_meter_profile_profile,
1154                 (void *)&cmd_set_port_meter_profile_port_id,
1155                 (void *)&cmd_set_port_meter_profile_mtr_id,
1156                 (void *)&cmd_set_port_meter_profile_profile_id,
1157                 NULL,
1158         },
1159 };
1160
1161 /* *** Set Port Meter DSCP Table *** */
1162 struct cmd_set_port_meter_dscp_table_result {
1163         cmdline_fixed_string_t set;
1164         cmdline_fixed_string_t port;
1165         cmdline_fixed_string_t meter;
1166         cmdline_fixed_string_t dscp_table;
1167         cmdline_multi_string_t token_string;
1168 };
1169
1170 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_set =
1171         TOKEN_STRING_INITIALIZER(
1172                 struct cmd_set_port_meter_dscp_table_result, set, "set");
1173 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_port =
1174         TOKEN_STRING_INITIALIZER(
1175                 struct cmd_set_port_meter_dscp_table_result, port, "port");
1176 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_meter =
1177         TOKEN_STRING_INITIALIZER(
1178                 struct cmd_set_port_meter_dscp_table_result, meter, "meter");
1179 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_dscp_table =
1180         TOKEN_STRING_INITIALIZER(
1181                 struct cmd_set_port_meter_dscp_table_result,
1182                 dscp_table, "dscp table");
1183 cmdline_parse_token_string_t cmd_set_port_meter_dscp_table_token_string =
1184         TOKEN_STRING_INITIALIZER(struct cmd_set_port_meter_dscp_table_result,
1185                 token_string, TOKEN_STRING_MULTI);
1186
1187 static void cmd_set_port_meter_dscp_table_parsed(void *parsed_result,
1188         __rte_unused struct cmdline *cl,
1189         __rte_unused void *data)
1190 {
1191         struct cmd_set_port_meter_dscp_table_result *res = parsed_result;
1192         struct rte_mtr_error error;
1193         enum rte_color *dscp_table = NULL;
1194         char *t_str = res->token_string;
1195         uint32_t mtr_id = 0;
1196         uint16_t port_id;
1197         int ret;
1198
1199         /* Parse string */
1200         ret = parse_multi_token_string(t_str, &port_id, &mtr_id, &dscp_table);
1201         if (ret) {
1202                 printf(" Multi token string parse error\n");
1203                 return;
1204         }
1205
1206         if (port_id_is_invalid(port_id, ENABLED_WARN))
1207                 goto free_table;
1208
1209         /* Update Meter DSCP Table*/
1210         ret = rte_mtr_meter_dscp_table_update(port_id, mtr_id,
1211                 dscp_table, &error);
1212         if (ret != 0)
1213                 print_err_msg(&error);
1214
1215 free_table:
1216         free(dscp_table);
1217 }
1218
1219 cmdline_parse_inst_t cmd_set_port_meter_dscp_table = {
1220         .f = cmd_set_port_meter_dscp_table_parsed,
1221         .data = NULL,
1222         .help_str = "set port meter dscp table <port_id> <mtr_id> "
1223                 "[<dscp_tbl_entry0> <dscp_tbl_entry1> ... <dscp_tbl_entry63>]",
1224         .tokens = {
1225                 (void *)&cmd_set_port_meter_dscp_table_set,
1226                 (void *)&cmd_set_port_meter_dscp_table_port,
1227                 (void *)&cmd_set_port_meter_dscp_table_meter,
1228                 (void *)&cmd_set_port_meter_dscp_table_dscp_table,
1229                 (void *)&cmd_set_port_meter_dscp_table_token_string,
1230                 NULL,
1231         },
1232 };
1233
1234 /* *** Set Port Meter Stats Mask *** */
1235 struct cmd_set_port_meter_stats_mask_result {
1236         cmdline_fixed_string_t set;
1237         cmdline_fixed_string_t port;
1238         cmdline_fixed_string_t meter;
1239         cmdline_fixed_string_t stats;
1240         cmdline_fixed_string_t mask;
1241         uint16_t port_id;
1242         uint32_t mtr_id;
1243         uint64_t stats_mask;
1244 };
1245
1246 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_set =
1247         TOKEN_STRING_INITIALIZER(
1248                 struct cmd_set_port_meter_stats_mask_result, set, "set");
1249 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_port =
1250         TOKEN_STRING_INITIALIZER(
1251                 struct cmd_set_port_meter_stats_mask_result, port, "port");
1252 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_meter =
1253         TOKEN_STRING_INITIALIZER(
1254                 struct cmd_set_port_meter_stats_mask_result, meter, "meter");
1255 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_stats =
1256         TOKEN_STRING_INITIALIZER(
1257                 struct cmd_set_port_meter_stats_mask_result, stats, "stats");
1258 cmdline_parse_token_string_t cmd_set_port_meter_stats_mask_mask =
1259         TOKEN_STRING_INITIALIZER(
1260                 struct cmd_set_port_meter_stats_mask_result, mask, "mask");
1261 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_port_id =
1262         TOKEN_NUM_INITIALIZER(
1263                 struct cmd_set_port_meter_stats_mask_result, port_id,
1264                 RTE_UINT16);
1265 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_mtr_id =
1266         TOKEN_NUM_INITIALIZER(
1267                 struct cmd_set_port_meter_stats_mask_result, mtr_id,
1268                 RTE_UINT32);
1269 cmdline_parse_token_num_t cmd_set_port_meter_stats_mask_stats_mask =
1270         TOKEN_NUM_INITIALIZER(
1271                 struct cmd_set_port_meter_stats_mask_result, stats_mask,
1272                 RTE_UINT64);
1273
1274 static void cmd_set_port_meter_stats_mask_parsed(void *parsed_result,
1275         __rte_unused struct cmdline *cl,
1276         __rte_unused void *data)
1277 {
1278         struct cmd_set_port_meter_stats_mask_result *res = parsed_result;
1279         struct rte_mtr_error error;
1280         uint64_t stats_mask = res->stats_mask;
1281         uint32_t mtr_id = res->mtr_id;
1282         uint16_t port_id = res->port_id;
1283         int ret;
1284
1285         if (port_id_is_invalid(port_id, ENABLED_WARN))
1286                 return;
1287
1288         ret = rte_mtr_stats_update(port_id, mtr_id, stats_mask, &error);
1289         if (ret != 0) {
1290                 print_err_msg(&error);
1291                 return;
1292         }
1293 }
1294
1295 cmdline_parse_inst_t cmd_set_port_meter_stats_mask = {
1296         .f = cmd_set_port_meter_stats_mask_parsed,
1297         .data = NULL,
1298         .help_str = "set port meter stats mask <port_id> <mtr_id> <stats_mask>",
1299         .tokens = {
1300                 (void *)&cmd_set_port_meter_stats_mask_set,
1301                 (void *)&cmd_set_port_meter_stats_mask_port,
1302                 (void *)&cmd_set_port_meter_stats_mask_meter,
1303                 (void *)&cmd_set_port_meter_stats_mask_stats,
1304                 (void *)&cmd_set_port_meter_stats_mask_mask,
1305                 (void *)&cmd_set_port_meter_stats_mask_port_id,
1306                 (void *)&cmd_set_port_meter_stats_mask_mtr_id,
1307                 (void *)&cmd_set_port_meter_stats_mask_stats_mask,
1308                 NULL,
1309         },
1310 };
1311
1312 /* *** Show Port Meter Stats *** */
1313 struct cmd_show_port_meter_stats_result {
1314         cmdline_fixed_string_t show;
1315         cmdline_fixed_string_t port;
1316         cmdline_fixed_string_t meter;
1317         cmdline_fixed_string_t stats;
1318         uint16_t port_id;
1319         uint32_t mtr_id;
1320         cmdline_fixed_string_t clear;
1321 };
1322
1323 cmdline_parse_token_string_t cmd_show_port_meter_stats_show =
1324         TOKEN_STRING_INITIALIZER(
1325                 struct cmd_show_port_meter_stats_result, show, "show");
1326 cmdline_parse_token_string_t cmd_show_port_meter_stats_port =
1327         TOKEN_STRING_INITIALIZER(
1328                 struct cmd_show_port_meter_stats_result, port, "port");
1329 cmdline_parse_token_string_t cmd_show_port_meter_stats_meter =
1330         TOKEN_STRING_INITIALIZER(
1331                 struct cmd_show_port_meter_stats_result, meter, "meter");
1332 cmdline_parse_token_string_t cmd_show_port_meter_stats_stats =
1333         TOKEN_STRING_INITIALIZER(
1334                 struct cmd_show_port_meter_stats_result, stats, "stats");
1335 cmdline_parse_token_num_t cmd_show_port_meter_stats_port_id =
1336         TOKEN_NUM_INITIALIZER(
1337                 struct cmd_show_port_meter_stats_result, port_id, RTE_UINT16);
1338 cmdline_parse_token_num_t cmd_show_port_meter_stats_mtr_id =
1339         TOKEN_NUM_INITIALIZER(
1340                 struct cmd_show_port_meter_stats_result, mtr_id, RTE_UINT32);
1341 cmdline_parse_token_string_t cmd_show_port_meter_stats_clear =
1342         TOKEN_STRING_INITIALIZER(
1343                 struct cmd_show_port_meter_stats_result, clear, "yes#no");
1344
1345 static void cmd_show_port_meter_stats_parsed(void *parsed_result,
1346         __rte_unused struct cmdline *cl,
1347         __rte_unused void *data)
1348 {
1349         struct cmd_show_port_meter_stats_result *res = parsed_result;
1350         struct rte_mtr_stats stats;
1351         uint64_t stats_mask = 0;
1352         struct rte_mtr_error error;
1353         uint32_t mtr_id = res->mtr_id;
1354         uint32_t clear = 0;
1355         uint16_t port_id = res->port_id;
1356         int ret;
1357
1358         if (port_id_is_invalid(port_id, ENABLED_WARN))
1359                 return;
1360
1361         if (strcmp(res->clear, "yes") == 0)
1362                 clear = 1;
1363
1364         memset(&stats, 0, sizeof(struct rte_mtr_stats));
1365         ret = rte_mtr_stats_read(port_id, mtr_id, &stats,
1366                 &stats_mask, clear, &error);
1367         if (ret != 0) {
1368                 print_err_msg(&error);
1369                 return;
1370         }
1371
1372         /* Display stats */
1373         if (stats_mask & RTE_MTR_STATS_N_PKTS_GREEN)
1374                 printf("\tPkts G: %" PRIu64 "\n",
1375                         stats.n_pkts[RTE_COLOR_GREEN]);
1376         if (stats_mask & RTE_MTR_STATS_N_BYTES_GREEN)
1377                 printf("\tBytes G: %" PRIu64 "\n",
1378                         stats.n_bytes[RTE_COLOR_GREEN]);
1379         if (stats_mask & RTE_MTR_STATS_N_PKTS_YELLOW)
1380                 printf("\tPkts Y: %" PRIu64 "\n",
1381                         stats.n_pkts[RTE_COLOR_YELLOW]);
1382         if (stats_mask & RTE_MTR_STATS_N_BYTES_YELLOW)
1383                 printf("\tBytes Y: %" PRIu64 "\n",
1384                         stats.n_bytes[RTE_COLOR_YELLOW]);
1385         if (stats_mask & RTE_MTR_STATS_N_PKTS_RED)
1386                 printf("\tPkts R: %" PRIu64 "\n",
1387                         stats.n_pkts[RTE_COLOR_RED]);
1388         if (stats_mask & RTE_MTR_STATS_N_BYTES_RED)
1389                 printf("\tBytes R: %" PRIu64 "\n",
1390                         stats.n_bytes[RTE_COLOR_RED]);
1391         if (stats_mask & RTE_MTR_STATS_N_PKTS_DROPPED)
1392                 printf("\tPkts DROPPED: %" PRIu64 "\n",
1393                         stats.n_pkts_dropped);
1394         if (stats_mask & RTE_MTR_STATS_N_BYTES_DROPPED)
1395                 printf("\tBytes DROPPED: %" PRIu64 "\n",
1396                         stats.n_bytes_dropped);
1397 }
1398
1399 cmdline_parse_inst_t cmd_show_port_meter_stats = {
1400         .f = cmd_show_port_meter_stats_parsed,
1401         .data = NULL,
1402         .help_str = "show port meter stats <port_id> <mtr_id> <clear>(yes|no)",
1403         .tokens = {
1404                 (void *)&cmd_show_port_meter_stats_show,
1405                 (void *)&cmd_show_port_meter_stats_port,
1406                 (void *)&cmd_show_port_meter_stats_meter,
1407                 (void *)&cmd_show_port_meter_stats_stats,
1408                 (void *)&cmd_show_port_meter_stats_port_id,
1409                 (void *)&cmd_show_port_meter_stats_mtr_id,
1410                 (void *)&cmd_show_port_meter_stats_clear,
1411                 NULL,
1412         },
1413 };