app/test-pmd/cmdline_tm.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_tm.h>
  12
  13 #include "testpmd.h"
  14 #include "cmdline_tm.h"
  15
  16 #define PARSE_DELIMITER                         " \f\n\r\t\v"
  17 #define MAX_NUM_SHARED_SHAPERS          256
  18
  19 #define skip_white_spaces(pos)                  \
  20 ({                                              \
  21         __typeof__(pos) _p = (pos);             \
  22         for ( ; isspace(*_p); _p++)             \
  23                 ;                               \
  24         _p;                                     \
  25 })
  26
  27 /** Display TM Error Message */
  28 static void
  29 print_err_msg(struct rte_tm_error *error)
  30 {
  31         static const char *const errstrlist[] = {
  32                 [RTE_TM_ERROR_TYPE_NONE] = "no error",
  33                 [RTE_TM_ERROR_TYPE_UNSPECIFIED] = "cause unspecified",
  34                 [RTE_TM_ERROR_TYPE_CAPABILITIES]
  35                         = "capability parameter null",
  36                 [RTE_TM_ERROR_TYPE_LEVEL_ID] = "level id",
  37                 [RTE_TM_ERROR_TYPE_WRED_PROFILE]
  38                         = "wred profile null",
  39                 [RTE_TM_ERROR_TYPE_WRED_PROFILE_GREEN] = "wred profile(green)",
  40                 [RTE_TM_ERROR_TYPE_WRED_PROFILE_YELLOW]
  41                         = "wred profile(yellow)",
  42                 [RTE_TM_ERROR_TYPE_WRED_PROFILE_RED] = "wred profile(red)",
  43                 [RTE_TM_ERROR_TYPE_WRED_PROFILE_ID] = "wred profile id",
  44                 [RTE_TM_ERROR_TYPE_SHARED_WRED_CONTEXT_ID]
  45                         = "shared wred context id",
  46                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE] = "shaper profile null",
  47                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_RATE]
  48                         = "committed rate field (shaper profile)",
  49                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_SIZE]
  50                         = "committed size field (shaper profile)",
  51                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_RATE]
  52                         = "peak rate field (shaper profile)",
  53                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_SIZE]
  54                         = "peak size field (shaper profile)",
  55                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PKT_ADJUST_LEN]
  56                         = "packet adjust length field (shaper profile)",
  57                 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID] = "shaper profile id",
  58                 [RTE_TM_ERROR_TYPE_SHARED_SHAPER_ID] = "shared shaper id",
  59                 [RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID] = "parent node id",
  60                 [RTE_TM_ERROR_TYPE_NODE_PRIORITY] = "node priority",
  61                 [RTE_TM_ERROR_TYPE_NODE_WEIGHT] = "node weight",
  62                 [RTE_TM_ERROR_TYPE_NODE_PARAMS] = "node parameter null",
  63                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_SHAPER_PROFILE_ID]
  64                         = "shaper profile id field (node params)",
  65                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_SHAPER_ID]
  66                         = "shared shaper id field (node params)",
  67                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS]
  68                         = "num shared shapers field (node params)",
  69                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE]
  70                         = "wfq weght mode field (node params)",
  71                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SP_PRIORITIES]
  72                         = "num strict priorities field (node params)",
  73                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_CMAN]
  74                         = "congestion management mode field (node params)",
  75                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_WRED_PROFILE_ID] =
  76                         "wred profile id field (node params)",
  77                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_WRED_CONTEXT_ID]
  78                         = "shared wred context id field (node params)",
  79                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_WRED_CONTEXTS]
  80                         = "num shared wred contexts field (node params)",
  81                 [RTE_TM_ERROR_TYPE_NODE_PARAMS_STATS]
  82                         = "stats field (node params)",
  83                 [RTE_TM_ERROR_TYPE_NODE_ID] = "node id",
  84         };
  85
  86         const char *errstr;
  87         char buf[64];
  88
  89         if ((unsigned int)error->type >= RTE_DIM(errstrlist) ||
  90                 !errstrlist[error->type])
  91                 errstr = "unknown type";
  92         else
  93                 errstr = errstrlist[error->type];
  94
  95         if (error->cause)
  96                 snprintf(buf, sizeof(buf), "cause: %p, ", error->cause);
  97
  98         printf("%s: %s%s (error %d)\n", errstr, error->cause ? buf : "",
  99                 error->message ? error->message : "(no stated reason)",
 100                 error->type);
 101 }
 102
 103 static int
 104 read_uint64(uint64_t *value, const char *p)
 105 {
 106         char *next;
 107         uint64_t val;
 108
 109         p = skip_white_spaces(p);
 110         if (!isdigit(*p))
 111                 return -EINVAL;
 112
 113         val = strtoul(p, &next, 10);
 114         if (p == next)
 115                 return -EINVAL;
 116
 117         p = next;
 118         switch (*p) {
 119         case 'T':
 120                 val *= 1024ULL;
 121                 /* fall through */
 122         case 'G':
 123                 val *= 1024ULL;
 124                 /* fall through */
 125         case 'M':
 126                 val *= 1024ULL;
 127                 /* fall through */
 128         case 'k':
 129         case 'K':
 130                 val *= 1024ULL;
 131                 p++;
 132                 break;
 133         }
 134
 135         p = skip_white_spaces(p);
 136         if (*p != '\0')
 137                 return -EINVAL;
 138
 139         *value = val;
 140         return 0;
 141 }
 142
 143 static int
 144 read_uint32(uint32_t *value, const char *p)
 145 {
 146         uint64_t val = 0;
 147         int ret = read_uint64(&val, p);
 148
 149         if (ret < 0)
 150                 return ret;
 151
 152         if (val > UINT32_MAX)
 153                 return -ERANGE;
 154
 155         *value = val;
 156         return 0;
 157 }
 158
 159 static int
 160 parse_multi_ss_id_str(char *s_str, uint32_t *n_ssp, uint32_t shaper_id[])
 161 {
 162         uint32_t n_shared_shapers = 0, i = 0;
 163         char *token;
 164
 165         /* First token: num of shared shapers */
 166         token = strtok_r(s_str, PARSE_DELIMITER, &s_str);
 167         if (token ==  NULL)
 168                 return -1;
 169
 170         if (read_uint32(&n_shared_shapers, token))
 171                 return -1;
 172
 173         /* Check: num of shared shaper */
 174         if (n_shared_shapers >= MAX_NUM_SHARED_SHAPERS) {
 175                 printf(" Number of shared shapers exceed the max (error)\n");
 176                 return -1;
 177         }
 178
 179         /* Parse shared shaper ids */
 180         while (1) {
 181                 token = strtok_r(s_str, PARSE_DELIMITER, &s_str);
 182                 if ((token !=  NULL && n_shared_shapers == 0) ||
 183                         (token == NULL && i < n_shared_shapers))
 184                         return -1;
 185
 186                 if (token == NULL)
 187                         break;
 188
 189                 if (read_uint32(&shaper_id[i], token))
 190                         return -1;
 191                 i++;
 192         }
 193         *n_ssp = n_shared_shapers;
 194
 195         return 0;
 196 }
 197 /* *** Port TM Capability *** */
 198 struct cmd_show_port_tm_cap_result {
 199         cmdline_fixed_string_t show;
 200         cmdline_fixed_string_t port;
 201         cmdline_fixed_string_t tm;
 202         cmdline_fixed_string_t cap;
 203         uint16_t port_id;
 204 };
 205
 206 cmdline_parse_token_string_t cmd_show_port_tm_cap_show =
 207         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
 208                 show, "show");
 209 cmdline_parse_token_string_t cmd_show_port_tm_cap_port =
 210         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
 211                 port, "port");
 212 cmdline_parse_token_string_t cmd_show_port_tm_cap_tm =
 213         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
 214                 tm, "tm");
 215 cmdline_parse_token_string_t cmd_show_port_tm_cap_cap =
 216         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
 217                 cap, "cap");
 218 cmdline_parse_token_num_t cmd_show_port_tm_cap_port_id =
 219         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_cap_result,
 220                  port_id, UINT16);
 221
 222 static void cmd_show_port_tm_cap_parsed(void *parsed_result,
 223         __attribute__((unused)) struct cmdline *cl,
 224         __attribute__((unused)) void *data)
 225 {
 226         struct cmd_show_port_tm_cap_result *res = parsed_result;
 227         struct rte_tm_capabilities cap;
 228         struct rte_tm_error error;
 229         portid_t port_id = res->port_id;
 230         uint32_t i;
 231         int ret;
 232
 233         if (port_id_is_invalid(port_id, ENABLED_WARN))
 234                 return;
 235
 236         memset(&cap, 0, sizeof(struct rte_tm_capabilities));
 237         memset(&error, 0, sizeof(struct rte_tm_error));
 238         ret = rte_tm_capabilities_get(port_id, &cap, &error);
 239         if (ret) {
 240                 print_err_msg(&error);
 241                 return;
 242         }
 243
 244         printf("\n****   Port TM Capabilities ****\n\n");
 245         printf("cap.n_nodes_max %" PRIu32 "\n", cap.n_nodes_max);
 246         printf("cap.n_levels_max %" PRIu32 "\n", cap.n_levels_max);
 247         printf("cap.non_leaf_nodes_identical %" PRId32 "\n",
 248                 cap.non_leaf_nodes_identical);
 249         printf("cap.leaf_nodes_identical %" PRId32 "\n",
 250                 cap.leaf_nodes_identical);
 251         printf("cap.shaper_n_max %u\n", cap.shaper_n_max);
 252         printf("cap.shaper_private_n_max %" PRIu32 "\n",
 253                 cap.shaper_private_n_max);
 254         printf("cap.shaper_private_dual_rate_n_max %" PRId32 "\n",
 255                 cap.shaper_private_dual_rate_n_max);
 256         printf("cap.shaper_private_rate_min %" PRIu64 "\n",
 257                 cap.shaper_private_rate_min);
 258         printf("cap.shaper_private_rate_max %" PRIu64 "\n",
 259                 cap.shaper_private_rate_max);
 260         printf("cap.shaper_shared_n_max %" PRIu32 "\n",
 261                 cap.shaper_shared_n_max);
 262         printf("cap.shaper_shared_n_nodes_per_shaper_max %" PRIu32 "\n",
 263                 cap.shaper_shared_n_nodes_per_shaper_max);
 264         printf("cap.shaper_shared_n_shapers_per_node_max %" PRIu32 "\n",
 265                 cap.shaper_shared_n_shapers_per_node_max);
 266         printf("cap.shaper_shared_dual_rate_n_max %" PRIu32 "\n",
 267                 cap.shaper_shared_dual_rate_n_max);
 268         printf("cap.shaper_shared_rate_min %" PRIu64 "\n",
 269                 cap.shaper_shared_rate_min);
 270         printf("cap.shaper_shared_rate_max %" PRIu64 "\n",
 271                 cap.shaper_shared_rate_max);
 272         printf("cap.shaper_pkt_length_adjust_min %" PRId32 "\n",
 273                 cap.shaper_pkt_length_adjust_min);
 274         printf("cap.shaper_pkt_length_adjust_max %" PRId32 "\n",
 275                 cap.shaper_pkt_length_adjust_max);
 276         printf("cap.sched_n_children_max %" PRIu32 "\n",
 277                 cap.sched_n_children_max);
 278         printf("cap.sched_sp_n_priorities_max %" PRIu32 "\n",
 279                 cap.sched_sp_n_priorities_max);
 280         printf("cap.sched_wfq_n_children_per_group_max %" PRIu32 "\n",
 281                 cap.sched_wfq_n_children_per_group_max);
 282         printf("cap.sched_wfq_n_groups_max %" PRIu32 "\n",
 283                 cap.sched_wfq_n_groups_max);
 284         printf("cap.sched_wfq_weight_max %" PRIu32 "\n",
 285                 cap.sched_wfq_weight_max);
 286         printf("cap.cman_head_drop_supported %" PRId32 "\n",
 287                 cap.cman_head_drop_supported);
 288         printf("cap.cman_wred_context_n_max %" PRIu32 "\n",
 289                 cap.cman_wred_context_n_max);
 290         printf("cap.cman_wred_context_private_n_max %" PRIu32 "\n",
 291                 cap.cman_wred_context_private_n_max);
 292         printf("cap.cman_wred_context_shared_n_max %" PRIu32 "\n",
 293                 cap.cman_wred_context_shared_n_max);
 294         printf("cap.cman_wred_context_shared_n_nodes_per_context_max %" PRIu32
 295                 "\n", cap.cman_wred_context_shared_n_nodes_per_context_max);
 296         printf("cap.cman_wred_context_shared_n_contexts_per_node_max %" PRIu32
 297                 "\n", cap.cman_wred_context_shared_n_contexts_per_node_max);
 298
 299         for (i = 0; i < RTE_COLORS; i++) {
 300                 printf("cap.mark_vlan_dei_supported %" PRId32 "\n",
 301                         cap.mark_vlan_dei_supported[i]);
 302                 printf("cap.mark_ip_ecn_tcp_supported %" PRId32 "\n",
 303                         cap.mark_ip_ecn_tcp_supported[i]);
 304                 printf("cap.mark_ip_ecn_sctp_supported %" PRId32 "\n",
 305                         cap.mark_ip_ecn_sctp_supported[i]);
 306                 printf("cap.mark_ip_dscp_supported %" PRId32 "\n",
 307                         cap.mark_ip_dscp_supported[i]);
 308         }
 309
 310         printf("cap.dynamic_update_mask %" PRIx64 "\n",
 311                 cap.dynamic_update_mask);
 312         printf("cap.stats_mask %" PRIx64 "\n", cap.stats_mask);
 313 }
 314
 315 cmdline_parse_inst_t cmd_show_port_tm_cap = {
 316         .f = cmd_show_port_tm_cap_parsed,
 317         .data = NULL,
 318         .help_str = "Show Port TM Capabilities",
 319         .tokens = {
 320                 (void *)&cmd_show_port_tm_cap_show,
 321                 (void *)&cmd_show_port_tm_cap_port,
 322                 (void *)&cmd_show_port_tm_cap_tm,
 323                 (void *)&cmd_show_port_tm_cap_cap,
 324                 (void *)&cmd_show_port_tm_cap_port_id,
 325                 NULL,
 326         },
 327 };
 328
 329 /* *** Port TM Hierarchical Level Capability *** */
 330 struct cmd_show_port_tm_level_cap_result {
 331         cmdline_fixed_string_t show;
 332         cmdline_fixed_string_t port;
 333         cmdline_fixed_string_t tm;
 334         cmdline_fixed_string_t level;
 335         cmdline_fixed_string_t cap;
 336         uint16_t port_id;
 337         uint32_t level_id;
 338 };
 339
 340 cmdline_parse_token_string_t cmd_show_port_tm_level_cap_show =
 341         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 342                 show, "show");
 343 cmdline_parse_token_string_t cmd_show_port_tm_level_cap_port =
 344         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 345                 port, "port");
 346 cmdline_parse_token_string_t cmd_show_port_tm_level_cap_tm =
 347         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 348                 tm, "tm");
 349 cmdline_parse_token_string_t cmd_show_port_tm_level_cap_level =
 350         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 351                 level, "level");
 352 cmdline_parse_token_string_t cmd_show_port_tm_level_cap_cap =
 353         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 354                 cap, "cap");
 355 cmdline_parse_token_num_t cmd_show_port_tm_level_cap_port_id =
 356         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 357                  port_id, UINT16);
 358 cmdline_parse_token_num_t cmd_show_port_tm_level_cap_level_id =
 359         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_level_cap_result,
 360                  level_id, UINT32);
 361
 362
 363 static void cmd_show_port_tm_level_cap_parsed(void *parsed_result,
 364         __attribute__((unused)) struct cmdline *cl,
 365         __attribute__((unused)) void *data)
 366 {
 367         struct cmd_show_port_tm_level_cap_result *res = parsed_result;
 368         struct rte_tm_level_capabilities lcap;
 369         struct rte_tm_error error;
 370         portid_t port_id = res->port_id;
 371         uint32_t level_id = res->level_id;
 372         int ret;
 373
 374         if (port_id_is_invalid(port_id, ENABLED_WARN))
 375                 return;
 376
 377         memset(&lcap, 0, sizeof(struct rte_tm_level_capabilities));
 378         memset(&error, 0, sizeof(struct rte_tm_error));
 379         ret = rte_tm_level_capabilities_get(port_id, level_id, &lcap, &error);
 380         if (ret) {
 381                 print_err_msg(&error);
 382                 return;
 383         }
 384         printf("\n**   Port TM Hierarchy level %" PRIu32 " Capability **\n\n",
 385                 level_id);
 386
 387         printf("cap.n_nodes_max %" PRIu32 "\n", lcap.n_nodes_max);
 388         printf("cap.n_nodes_nonleaf_max %" PRIu32 "\n",
 389                 lcap.n_nodes_nonleaf_max);
 390         printf("cap.n_nodes_leaf_max %" PRIu32 "\n", lcap.n_nodes_leaf_max);
 391         printf("cap.non_leaf_nodes_identical %" PRId32 "\n",
 392                 lcap.non_leaf_nodes_identical);
 393         printf("cap.leaf_nodes_identical %" PRId32 "\n",
 394                 lcap.leaf_nodes_identical);
 395         if (level_id <= 3) {
 396                 printf("cap.nonleaf.shaper_private_supported %" PRId32 "\n",
 397                         lcap.nonleaf.shaper_private_supported);
 398                 printf("cap.nonleaf.shaper_private_dual_rate_supported %" PRId32
 399                         "\n", lcap.nonleaf.shaper_private_dual_rate_supported);
 400                 printf("cap.nonleaf.shaper_private_rate_min %" PRIu64 "\n",
 401                         lcap.nonleaf.shaper_private_rate_min);
 402                 printf("cap.nonleaf.shaper_private_rate_max %" PRIu64 "\n",
 403                         lcap.nonleaf.shaper_private_rate_max);
 404                 printf("cap.nonleaf.shaper_shared_n_max %" PRIu32 "\n",
 405                         lcap.nonleaf.shaper_shared_n_max);
 406                 printf("cap.nonleaf.sched_n_children_max %" PRIu32 "\n",
 407                         lcap.nonleaf.sched_n_children_max);
 408                 printf("cap.nonleaf.sched_sp_n_priorities_max %" PRIu32 "\n",
 409                         lcap.nonleaf.sched_sp_n_priorities_max);
 410                 printf("cap.nonleaf.sched_wfq_n_children_per_group_max %" PRIu32
 411                         "\n", lcap.nonleaf.sched_wfq_n_children_per_group_max);
 412                 printf("cap.nonleaf.sched_wfq_n_groups_max %" PRIu32 "\n",
 413                         lcap.nonleaf.sched_wfq_n_groups_max);
 414                 printf("cap.nonleaf.sched_wfq_weight_max %" PRIu32 "\n",
 415                         lcap.nonleaf.sched_wfq_weight_max);
 416                 printf("cap.nonleaf.stats_mask %" PRIx64 "\n",
 417                         lcap.nonleaf.stats_mask);
 418         } else {
 419                 printf("cap.leaf.shaper_private_supported %" PRId32 "\n",
 420                         lcap.leaf.shaper_private_supported);
 421                 printf("cap.leaf.shaper_private_dual_rate_supported %" PRId32
 422                         "\n", lcap.leaf.shaper_private_dual_rate_supported);
 423                 printf("cap.leaf.shaper_private_rate_min %" PRIu64 "\n",
 424                         lcap.leaf.shaper_private_rate_min);
 425                 printf("cap.leaf.shaper_private_rate_max %" PRIu64 "\n",
 426                         lcap.leaf.shaper_private_rate_max);
 427                 printf("cap.leaf.shaper_shared_n_max %" PRIu32 "\n",
 428                         lcap.leaf.shaper_shared_n_max);
 429                 printf("cap.leaf.cman_head_drop_supported %" PRId32 "\n",
 430                         lcap.leaf.cman_head_drop_supported);
 431                 printf("cap.leaf.cman_wred_context_private_supported %" PRId32
 432                         "\n", lcap.leaf.cman_wred_context_private_supported);
 433                 printf("cap.leaf.cman_wred_context_shared_n_max %" PRIu32 "\n",
 434                         lcap.leaf.cman_wred_context_shared_n_max);
 435                 printf("cap.leaf.stats_mask %" PRIx64 "\n",
 436                         lcap.leaf.stats_mask);
 437         }
 438 }
 439
 440 cmdline_parse_inst_t cmd_show_port_tm_level_cap = {
 441         .f = cmd_show_port_tm_level_cap_parsed,
 442         .data = NULL,
 443         .help_str = "Show Port TM Hierarhical level Capabilities",
 444         .tokens = {
 445                 (void *)&cmd_show_port_tm_level_cap_show,
 446                 (void *)&cmd_show_port_tm_level_cap_port,
 447                 (void *)&cmd_show_port_tm_level_cap_tm,
 448                 (void *)&cmd_show_port_tm_level_cap_level,
 449                 (void *)&cmd_show_port_tm_level_cap_cap,
 450                 (void *)&cmd_show_port_tm_level_cap_port_id,
 451                 (void *)&cmd_show_port_tm_level_cap_level_id,
 452                 NULL,
 453         },
 454 };
 455
 456 /* *** Port TM Hierarchy Node Capability *** */
 457 struct cmd_show_port_tm_node_cap_result {
 458         cmdline_fixed_string_t show;
 459         cmdline_fixed_string_t port;
 460         cmdline_fixed_string_t tm;
 461         cmdline_fixed_string_t node;
 462         cmdline_fixed_string_t cap;
 463         uint16_t port_id;
 464         uint32_t node_id;
 465 };
 466
 467 cmdline_parse_token_string_t cmd_show_port_tm_node_cap_show =
 468         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 469                 show, "show");
 470 cmdline_parse_token_string_t cmd_show_port_tm_node_cap_port =
 471         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 472                 port, "port");
 473 cmdline_parse_token_string_t cmd_show_port_tm_node_cap_tm =
 474         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 475                 tm, "tm");
 476 cmdline_parse_token_string_t cmd_show_port_tm_node_cap_node =
 477         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 478                 node, "node");
 479 cmdline_parse_token_string_t cmd_show_port_tm_node_cap_cap =
 480         TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 481                 cap, "cap");
 482 cmdline_parse_token_num_t cmd_show_port_tm_node_cap_port_id =
 483         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 484                  port_id, UINT16);
 485 cmdline_parse_token_num_t cmd_show_port_tm_node_cap_node_id =
 486         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_node_cap_result,
 487                  node_id, UINT32);
 488
 489 static void cmd_show_port_tm_node_cap_parsed(void *parsed_result,
 490         __attribute__((unused)) struct cmdline *cl,
 491         __attribute__((unused)) void *data)
 492 {
 493         struct cmd_show_port_tm_node_cap_result *res = parsed_result;
 494         struct rte_tm_node_capabilities ncap;
 495         struct rte_tm_error error;
 496         uint32_t node_id = res->node_id;
 497         portid_t port_id = res->port_id;
 498         int ret, is_leaf = 0;
 499
 500         if (port_id_is_invalid(port_id, ENABLED_WARN))
 501                 return;
 502
 503         memset(&error, 0, sizeof(struct rte_tm_error));
 504         /* Node id must be valid */
 505         ret = rte_tm_node_type_get(port_id, node_id, &is_leaf, &error);
 506         if (ret != 0) {
 507                 print_err_msg(&error);
 508                 return;
 509         }
 510
 511         memset(&ncap, 0, sizeof(struct rte_tm_node_capabilities));
 512         ret = rte_tm_node_capabilities_get(port_id, node_id, &ncap, &error);
 513         if (ret != 0) {
 514                 print_err_msg(&error);
 515                 return;
 516         }
 517         printf("\n**   Port TM Hierarchy node %" PRIu32 " Capability **\n\n",
 518                 node_id);
 519         printf("cap.shaper_private_supported %" PRId32 "\n",
 520                 ncap.shaper_private_supported);
 521         printf("cap.shaper_private_dual_rate_supported %" PRId32 "\n",
 522                 ncap.shaper_private_dual_rate_supported);
 523         printf("cap.shaper_private_rate_min %" PRIu64 "\n",
 524                 ncap.shaper_private_rate_min);
 525         printf("cap.shaper_private_rate_max %" PRIu64 "\n",
 526                 ncap.shaper_private_rate_max);
 527         printf("cap.shaper_shared_n_max %" PRIu32 "\n",
 528                 ncap.shaper_shared_n_max);
 529         if (!is_leaf) {
 530                 printf("cap.nonleaf.sched_n_children_max %" PRIu32 "\n",
 531                         ncap.nonleaf.sched_n_children_max);
 532                 printf("cap.nonleaf.sched_sp_n_priorities_max %" PRIu32 "\n",
 533                         ncap.nonleaf.sched_sp_n_priorities_max);
 534                 printf("cap.nonleaf.sched_wfq_n_children_per_group_max %" PRIu32
 535                         "\n", ncap.nonleaf.sched_wfq_n_children_per_group_max);
 536                 printf("cap.nonleaf.sched_wfq_n_groups_max %" PRIu32 "\n",
 537                         ncap.nonleaf.sched_wfq_n_groups_max);
 538                 printf("cap.nonleaf.sched_wfq_weight_max %" PRIu32 "\n",
 539                         ncap.nonleaf.sched_wfq_weight_max);
 540         } else {
 541                 printf("cap.leaf.cman_head_drop_supported %" PRId32 "\n",
 542                         ncap.leaf.cman_head_drop_supported);
 543                 printf("cap.leaf.cman_wred_context_private_supported %" PRId32
 544                         "\n", ncap.leaf.cman_wred_context_private_supported);
 545                 printf("cap.leaf.cman_wred_context_shared_n_max %" PRIu32 "\n",
 546                         ncap.leaf.cman_wred_context_shared_n_max);
 547         }
 548         printf("cap.stats_mask %" PRIx64 "\n", ncap.stats_mask);
 549 }
 550
 551 cmdline_parse_inst_t cmd_show_port_tm_node_cap = {
 552         .f = cmd_show_port_tm_node_cap_parsed,
 553         .data = NULL,
 554         .help_str = "Show Port TM Hierarchy node capabilities",
 555         .tokens = {
 556                 (void *)&cmd_show_port_tm_node_cap_show,
 557                 (void *)&cmd_show_port_tm_node_cap_port,
 558                 (void *)&cmd_show_port_tm_node_cap_tm,
 559                 (void *)&cmd_show_port_tm_node_cap_node,
 560                 (void *)&cmd_show_port_tm_node_cap_cap,
 561                 (void *)&cmd_show_port_tm_node_cap_port_id,
 562                 (void *)&cmd_show_port_tm_node_cap_node_id,
 563                 NULL,
 564         },
 565 };
 566
 567 /* *** Show Port TM Node Statistics *** */
 568 struct cmd_show_port_tm_node_stats_result {
 569         cmdline_fixed_string_t show;
 570         cmdline_fixed_string_t port;
 571         cmdline_fixed_string_t tm;
 572         cmdline_fixed_string_t node;
 573         cmdline_fixed_string_t stats;
 574         uint16_t port_id;
 575         uint32_t node_id;
 576         uint32_t clear;
 577 };
 578
 579 cmdline_parse_token_string_t cmd_show_port_tm_node_stats_show =
 580         TOKEN_STRING_INITIALIZER(
 581                 struct cmd_show_port_tm_node_stats_result, show, "show");
 582 cmdline_parse_token_string_t cmd_show_port_tm_node_stats_port =
 583         TOKEN_STRING_INITIALIZER(
 584                 struct cmd_show_port_tm_node_stats_result, port, "port");
 585 cmdline_parse_token_string_t cmd_show_port_tm_node_stats_tm =
 586         TOKEN_STRING_INITIALIZER(
 587                 struct cmd_show_port_tm_node_stats_result, tm, "tm");
 588 cmdline_parse_token_string_t cmd_show_port_tm_node_stats_node =
 589         TOKEN_STRING_INITIALIZER(
 590                 struct cmd_show_port_tm_node_stats_result, node, "node");
 591 cmdline_parse_token_string_t cmd_show_port_tm_node_stats_stats =
 592         TOKEN_STRING_INITIALIZER(
 593                 struct cmd_show_port_tm_node_stats_result, stats, "stats");
 594 cmdline_parse_token_num_t cmd_show_port_tm_node_stats_port_id =
 595         TOKEN_NUM_INITIALIZER(struct cmd_show_port_tm_node_stats_result,
 596                         port_id, UINT16);
 597 cmdline_parse_token_num_t cmd_show_port_tm_node_stats_node_id =
 598         TOKEN_NUM_INITIALIZER(
 599                 struct cmd_show_port_tm_node_stats_result,
 600                         node_id, UINT32);
 601 cmdline_parse_token_num_t cmd_show_port_tm_node_stats_clear =
 602         TOKEN_NUM_INITIALIZER(
 603                 struct cmd_show_port_tm_node_stats_result, clear, UINT32);
 604
 605 static void cmd_show_port_tm_node_stats_parsed(void *parsed_result,
 606         __attribute__((unused)) struct cmdline *cl,
 607         __attribute__((unused)) void *data)
 608 {
 609         struct cmd_show_port_tm_node_stats_result *res = parsed_result;
 610         struct rte_tm_node_stats stats;
 611         struct rte_tm_error error;
 612         uint64_t stats_mask = 0;
 613         uint32_t node_id = res->node_id;
 614         uint32_t clear = res->clear;
 615         portid_t port_id = res->port_id;
 616         int ret;
 617
 618         if (port_id_is_invalid(port_id, ENABLED_WARN))
 619                 return;
 620
 621         memset(&error, 0, sizeof(struct rte_tm_error));
 622         /* Port status */
 623         if (!port_is_started(port_id)) {
 624                 printf(" Port %u not started (error)\n", port_id);
 625                 return;
 626         }
 627
 628         memset(&stats, 0, sizeof(struct rte_tm_node_stats));
 629         ret = rte_tm_node_stats_read(port_id, node_id, &stats,
 630                         &stats_mask, clear, &error);
 631         if (ret != 0) {
 632                 print_err_msg(&error);
 633                 return;
 634         }
 635
 636         /* Display stats */
 637         if (stats_mask & RTE_TM_STATS_N_PKTS)
 638                 printf("\tPkts scheduled from node: %" PRIu64 "\n",
 639                         stats.n_pkts);
 640         if (stats_mask & RTE_TM_STATS_N_BYTES)
 641                 printf("\tBytes scheduled from node: %" PRIu64 "\n",
 642                         stats.n_bytes);
 643         if (stats_mask & RTE_TM_STATS_N_PKTS_GREEN_DROPPED)
 644                 printf("\tPkts dropped (green): %" PRIu64 "\n",
 645                         stats.leaf.n_pkts_dropped[RTE_COLOR_GREEN]);
 646         if (stats_mask & RTE_TM_STATS_N_PKTS_YELLOW_DROPPED)
 647                 printf("\tPkts dropped (yellow): %" PRIu64 "\n",
 648                         stats.leaf.n_pkts_dropped[RTE_COLOR_YELLOW]);
 649         if (stats_mask & RTE_TM_STATS_N_PKTS_RED_DROPPED)
 650                 printf("\tPkts dropped (red): %" PRIu64 "\n",
 651                         stats.leaf.n_pkts_dropped[RTE_COLOR_RED]);
 652         if (stats_mask & RTE_TM_STATS_N_BYTES_GREEN_DROPPED)
 653                 printf("\tBytes dropped (green): %" PRIu64 "\n",
 654                         stats.leaf.n_bytes_dropped[RTE_COLOR_GREEN]);
 655         if (stats_mask & RTE_TM_STATS_N_BYTES_YELLOW_DROPPED)
 656                 printf("\tBytes dropped (yellow): %" PRIu64 "\n",
 657                         stats.leaf.n_bytes_dropped[RTE_COLOR_YELLOW]);
 658         if (stats_mask & RTE_TM_STATS_N_BYTES_RED_DROPPED)
 659                 printf("\tBytes dropped (red): %" PRIu64 "\n",
 660                         stats.leaf.n_bytes_dropped[RTE_COLOR_RED]);
 661         if (stats_mask & RTE_TM_STATS_N_PKTS_QUEUED)
 662                 printf("\tPkts queued: %" PRIu64 "\n",
 663                         stats.leaf.n_pkts_queued);
 664         if (stats_mask & RTE_TM_STATS_N_BYTES_QUEUED)
 665                 printf("\tBytes queued: %" PRIu64 "\n",
 666                         stats.leaf.n_bytes_queued);
 667 }
 668
 669 cmdline_parse_inst_t cmd_show_port_tm_node_stats = {
 670         .f = cmd_show_port_tm_node_stats_parsed,
 671         .data = NULL,
 672         .help_str = "Show port tm node stats",
 673         .tokens = {
 674                 (void *)&cmd_show_port_tm_node_stats_show,
 675                 (void *)&cmd_show_port_tm_node_stats_port,
 676                 (void *)&cmd_show_port_tm_node_stats_tm,
 677                 (void *)&cmd_show_port_tm_node_stats_node,
 678                 (void *)&cmd_show_port_tm_node_stats_stats,
 679                 (void *)&cmd_show_port_tm_node_stats_port_id,
 680                 (void *)&cmd_show_port_tm_node_stats_node_id,
 681                 (void *)&cmd_show_port_tm_node_stats_clear,
 682                 NULL,
 683         },
 684 };
 685
 686 /* *** Show Port TM Node Type *** */
 687 struct cmd_show_port_tm_node_type_result {
 688         cmdline_fixed_string_t show;
 689         cmdline_fixed_string_t port;
 690         cmdline_fixed_string_t tm;
 691         cmdline_fixed_string_t node;
 692         cmdline_fixed_string_t type;
 693         uint16_t port_id;
 694         uint32_t node_id;
 695 };
 696
 697 cmdline_parse_token_string_t cmd_show_port_tm_node_type_show =
 698         TOKEN_STRING_INITIALIZER(
 699                 struct cmd_show_port_tm_node_type_result, show, "show");
 700 cmdline_parse_token_string_t cmd_show_port_tm_node_type_port =
 701         TOKEN_STRING_INITIALIZER(
 702                 struct cmd_show_port_tm_node_type_result, port, "port");
 703 cmdline_parse_token_string_t cmd_show_port_tm_node_type_tm =
 704         TOKEN_STRING_INITIALIZER(
 705                 struct cmd_show_port_tm_node_type_result, tm, "tm");
 706 cmdline_parse_token_string_t cmd_show_port_tm_node_type_node =
 707         TOKEN_STRING_INITIALIZER(
 708                 struct cmd_show_port_tm_node_type_result, node, "node");
 709 cmdline_parse_token_string_t cmd_show_port_tm_node_type_type =
 710         TOKEN_STRING_INITIALIZER(
 711                 struct cmd_show_port_tm_node_type_result, type, "type");
 712 cmdline_parse_token_num_t cmd_show_port_tm_node_type_port_id =
 713         TOKEN_NUM_INITIALIZER(
 714                 struct cmd_show_port_tm_node_type_result,
 715                         port_id, UINT16);
 716 cmdline_parse_token_num_t cmd_show_port_tm_node_type_node_id =
 717         TOKEN_NUM_INITIALIZER(
 718                 struct cmd_show_port_tm_node_type_result,
 719                         node_id, UINT32);
 720
 721 static void cmd_show_port_tm_node_type_parsed(void *parsed_result,
 722         __attribute__((unused)) struct cmdline *cl,
 723         __attribute__((unused)) void *data)
 724 {
 725         struct cmd_show_port_tm_node_type_result *res = parsed_result;
 726         struct rte_tm_error error;
 727         uint32_t node_id = res->node_id;
 728         portid_t port_id = res->port_id;
 729         int ret, is_leaf = 0;
 730
 731         if (port_id_is_invalid(port_id, ENABLED_WARN))
 732                 return;
 733
 734         memset(&error, 0, sizeof(struct rte_tm_error));
 735         ret = rte_tm_node_type_get(port_id, node_id, &is_leaf, &error);
 736         if (ret != 0) {
 737                 print_err_msg(&error);
 738                 return;
 739         }
 740
 741         if (is_leaf == 1)
 742                 printf("leaf node\n");
 743         else
 744                 printf("nonleaf node\n");
 745
 746 }
 747
 748 cmdline_parse_inst_t cmd_show_port_tm_node_type = {
 749         .f = cmd_show_port_tm_node_type_parsed,
 750         .data = NULL,
 751         .help_str = "Show port tm node type",
 752         .tokens = {
 753                 (void *)&cmd_show_port_tm_node_type_show,
 754                 (void *)&cmd_show_port_tm_node_type_port,
 755                 (void *)&cmd_show_port_tm_node_type_tm,
 756                 (void *)&cmd_show_port_tm_node_type_node,
 757                 (void *)&cmd_show_port_tm_node_type_type,
 758                 (void *)&cmd_show_port_tm_node_type_port_id,
 759                 (void *)&cmd_show_port_tm_node_type_node_id,
 760                 NULL,
 761         },
 762 };
 763
 764 /* *** Add Port TM Private Shaper Profile *** */
 765 struct cmd_add_port_tm_node_shaper_profile_result {
 766         cmdline_fixed_string_t add;
 767         cmdline_fixed_string_t port;
 768         cmdline_fixed_string_t tm;
 769         cmdline_fixed_string_t node;
 770         cmdline_fixed_string_t shaper;
 771         cmdline_fixed_string_t profile;
 772         uint16_t port_id;
 773         uint32_t shaper_id;
 774         uint64_t cmit_tb_rate;
 775         uint64_t cmit_tb_size;
 776         uint64_t peak_tb_rate;
 777         uint64_t peak_tb_size;
 778         uint32_t pktlen_adjust;
 779 };
 780
 781 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_add =
 782         TOKEN_STRING_INITIALIZER(
 783                 struct cmd_add_port_tm_node_shaper_profile_result, add, "add");
 784 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_port =
 785         TOKEN_STRING_INITIALIZER(
 786                 struct cmd_add_port_tm_node_shaper_profile_result,
 787                         port, "port");
 788 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_tm =
 789         TOKEN_STRING_INITIALIZER(
 790                 struct cmd_add_port_tm_node_shaper_profile_result,
 791                         tm, "tm");
 792 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_node =
 793         TOKEN_STRING_INITIALIZER(
 794                 struct cmd_add_port_tm_node_shaper_profile_result,
 795                         node, "node");
 796 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_shaper =
 797         TOKEN_STRING_INITIALIZER(
 798                 struct cmd_add_port_tm_node_shaper_profile_result,
 799                         shaper, "shaper");
 800 cmdline_parse_token_string_t cmd_add_port_tm_node_shaper_profile_profile =
 801         TOKEN_STRING_INITIALIZER(
 802                 struct cmd_add_port_tm_node_shaper_profile_result,
 803                         profile, "profile");
 804 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_port_id =
 805         TOKEN_NUM_INITIALIZER(
 806                 struct cmd_add_port_tm_node_shaper_profile_result,
 807                         port_id, UINT16);
 808 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_shaper_id =
 809         TOKEN_NUM_INITIALIZER(
 810                 struct cmd_add_port_tm_node_shaper_profile_result,
 811                         shaper_id, UINT32);
 812 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_cmit_tb_rate =
 813         TOKEN_NUM_INITIALIZER(
 814                 struct cmd_add_port_tm_node_shaper_profile_result,
 815                         cmit_tb_rate, UINT64);
 816 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_cmit_tb_size =
 817         TOKEN_NUM_INITIALIZER(
 818                 struct cmd_add_port_tm_node_shaper_profile_result,
 819                         cmit_tb_size, UINT64);
 820 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_peak_tb_rate =
 821         TOKEN_NUM_INITIALIZER(
 822                 struct cmd_add_port_tm_node_shaper_profile_result,
 823                         peak_tb_rate, UINT64);
 824 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_peak_tb_size =
 825         TOKEN_NUM_INITIALIZER(
 826                 struct cmd_add_port_tm_node_shaper_profile_result,
 827                         peak_tb_size, UINT64);
 828 cmdline_parse_token_num_t cmd_add_port_tm_node_shaper_profile_pktlen_adjust =
 829         TOKEN_NUM_INITIALIZER(
 830                 struct cmd_add_port_tm_node_shaper_profile_result,
 831                         pktlen_adjust, UINT32);
 832
 833 static void cmd_add_port_tm_node_shaper_profile_parsed(void *parsed_result,
 834         __attribute__((unused)) struct cmdline *cl,
 835         __attribute__((unused)) void *data)
 836 {
 837         struct cmd_add_port_tm_node_shaper_profile_result *res = parsed_result;
 838         struct rte_tm_shaper_params sp;
 839         struct rte_tm_error error;
 840         uint32_t shaper_id = res->shaper_id;
 841         uint32_t pkt_len_adjust = res->pktlen_adjust;
 842         portid_t port_id = res->port_id;
 843         int ret;
 844
 845         if (port_id_is_invalid(port_id, ENABLED_WARN))
 846                 return;
 847
 848         /* Private shaper profile params */
 849         memset(&sp, 0, sizeof(struct rte_tm_shaper_params));
 850         memset(&error, 0, sizeof(struct rte_tm_error));
 851         sp.committed.rate = res->cmit_tb_rate;
 852         sp.committed.size = res->cmit_tb_size;
 853         sp.peak.rate = res->peak_tb_rate;
 854         sp.peak.size = res->peak_tb_size;
 855         sp.pkt_length_adjust = pkt_len_adjust;
 856
 857         ret = rte_tm_shaper_profile_add(port_id, shaper_id, &sp, &error);
 858         if (ret != 0) {
 859                 print_err_msg(&error);
 860                 return;
 861         }
 862 }
 863
 864 cmdline_parse_inst_t cmd_add_port_tm_node_shaper_profile = {
 865         .f = cmd_add_port_tm_node_shaper_profile_parsed,
 866         .data = NULL,
 867         .help_str = "Add port tm node private shaper profile",
 868         .tokens = {
 869                 (void *)&cmd_add_port_tm_node_shaper_profile_add,
 870                 (void *)&cmd_add_port_tm_node_shaper_profile_port,
 871                 (void *)&cmd_add_port_tm_node_shaper_profile_tm,
 872                 (void *)&cmd_add_port_tm_node_shaper_profile_node,
 873                 (void *)&cmd_add_port_tm_node_shaper_profile_shaper,
 874                 (void *)&cmd_add_port_tm_node_shaper_profile_profile,
 875                 (void *)&cmd_add_port_tm_node_shaper_profile_port_id,
 876                 (void *)&cmd_add_port_tm_node_shaper_profile_shaper_id,
 877                 (void *)&cmd_add_port_tm_node_shaper_profile_cmit_tb_rate,
 878                 (void *)&cmd_add_port_tm_node_shaper_profile_cmit_tb_size,
 879                 (void *)&cmd_add_port_tm_node_shaper_profile_peak_tb_rate,
 880                 (void *)&cmd_add_port_tm_node_shaper_profile_peak_tb_size,
 881                 (void *)&cmd_add_port_tm_node_shaper_profile_pktlen_adjust,
 882                 NULL,
 883         },
 884 };
 885
 886 /* *** Delete Port TM Private Shaper Profile *** */
 887 struct cmd_del_port_tm_node_shaper_profile_result {
 888         cmdline_fixed_string_t del;
 889         cmdline_fixed_string_t port;
 890         cmdline_fixed_string_t tm;
 891         cmdline_fixed_string_t node;
 892         cmdline_fixed_string_t shaper;
 893         cmdline_fixed_string_t profile;
 894         uint16_t port_id;
 895         uint32_t shaper_id;
 896 };
 897
 898 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_del =
 899         TOKEN_STRING_INITIALIZER(
 900                 struct cmd_del_port_tm_node_shaper_profile_result, del, "del");
 901 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_port =
 902         TOKEN_STRING_INITIALIZER(
 903                 struct cmd_del_port_tm_node_shaper_profile_result,
 904                         port, "port");
 905 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_tm =
 906         TOKEN_STRING_INITIALIZER(
 907                 struct cmd_del_port_tm_node_shaper_profile_result, tm, "tm");
 908 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_node =
 909         TOKEN_STRING_INITIALIZER(
 910                 struct cmd_del_port_tm_node_shaper_profile_result,
 911                         node, "node");
 912 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_shaper =
 913         TOKEN_STRING_INITIALIZER(
 914                 struct cmd_del_port_tm_node_shaper_profile_result,
 915                         shaper, "shaper");
 916 cmdline_parse_token_string_t cmd_del_port_tm_node_shaper_profile_profile =
 917         TOKEN_STRING_INITIALIZER(
 918                 struct cmd_del_port_tm_node_shaper_profile_result,
 919                         profile, "profile");
 920 cmdline_parse_token_num_t cmd_del_port_tm_node_shaper_profile_port_id =
 921         TOKEN_NUM_INITIALIZER(
 922                 struct cmd_del_port_tm_node_shaper_profile_result,
 923                         port_id, UINT16);
 924 cmdline_parse_token_num_t cmd_del_port_tm_node_shaper_profile_shaper_id =
 925         TOKEN_NUM_INITIALIZER(
 926                 struct cmd_del_port_tm_node_shaper_profile_result,
 927                         shaper_id, UINT32);
 928
 929 static void cmd_del_port_tm_node_shaper_profile_parsed(void *parsed_result,
 930         __attribute__((unused)) struct cmdline *cl,
 931         __attribute__((unused)) void *data)
 932 {
 933         struct cmd_del_port_tm_node_shaper_profile_result *res = parsed_result;
 934         struct rte_tm_error error;
 935         uint32_t shaper_id = res->shaper_id;
 936         portid_t port_id = res->port_id;
 937         int ret;
 938
 939         if (port_id_is_invalid(port_id, ENABLED_WARN))
 940                 return;
 941
 942         memset(&error, 0, sizeof(struct rte_tm_error));
 943         ret = rte_tm_shaper_profile_delete(port_id, shaper_id, &error);
 944         if (ret != 0) {
 945                 print_err_msg(&error);
 946                 return;
 947         }
 948 }
 949
 950 cmdline_parse_inst_t cmd_del_port_tm_node_shaper_profile = {
 951         .f = cmd_del_port_tm_node_shaper_profile_parsed,
 952         .data = NULL,
 953         .help_str = "Delete port tm node private shaper profile",
 954         .tokens = {
 955                 (void *)&cmd_del_port_tm_node_shaper_profile_del,
 956                 (void *)&cmd_del_port_tm_node_shaper_profile_port,
 957                 (void *)&cmd_del_port_tm_node_shaper_profile_tm,
 958                 (void *)&cmd_del_port_tm_node_shaper_profile_node,
 959                 (void *)&cmd_del_port_tm_node_shaper_profile_shaper,
 960                 (void *)&cmd_del_port_tm_node_shaper_profile_profile,
 961                 (void *)&cmd_del_port_tm_node_shaper_profile_port_id,
 962                 (void *)&cmd_del_port_tm_node_shaper_profile_shaper_id,
 963                 NULL,
 964         },
 965 };
 966
 967 /* *** Add/Update Port TM shared Shaper *** */
 968 struct cmd_add_port_tm_node_shared_shaper_result {
 969         cmdline_fixed_string_t cmd_type;
 970         cmdline_fixed_string_t port;
 971         cmdline_fixed_string_t tm;
 972         cmdline_fixed_string_t node;
 973         cmdline_fixed_string_t shared;
 974         cmdline_fixed_string_t shaper;
 975         uint16_t port_id;
 976         uint32_t shared_shaper_id;
 977         uint32_t shaper_profile_id;
 978 };
 979
 980 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_cmd_type =
 981         TOKEN_STRING_INITIALIZER(
 982                 struct cmd_add_port_tm_node_shared_shaper_result,
 983                         cmd_type, "add#set");
 984 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_port =
 985         TOKEN_STRING_INITIALIZER(
 986                 struct cmd_add_port_tm_node_shared_shaper_result, port, "port");
 987 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_tm =
 988         TOKEN_STRING_INITIALIZER(
 989                 struct cmd_add_port_tm_node_shared_shaper_result, tm, "tm");
 990 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_node =
 991         TOKEN_STRING_INITIALIZER(
 992                 struct cmd_add_port_tm_node_shared_shaper_result, node, "node");
 993 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_shared =
 994         TOKEN_STRING_INITIALIZER(
 995                 struct cmd_add_port_tm_node_shared_shaper_result,
 996                         shared, "shared");
 997 cmdline_parse_token_string_t cmd_add_port_tm_node_shared_shaper_shaper =
 998         TOKEN_STRING_INITIALIZER(
 999                 struct cmd_add_port_tm_node_shared_shaper_result,
1000                         shaper, "shaper");
1001 cmdline_parse_token_num_t cmd_add_port_tm_node_shared_shaper_port_id =
1002         TOKEN_NUM_INITIALIZER(
1003                 struct cmd_add_port_tm_node_shared_shaper_result,
1004                         port_id, UINT16);
1005 cmdline_parse_token_num_t cmd_add_port_tm_node_shared_shaper_shared_shaper_id =
1006         TOKEN_NUM_INITIALIZER(
1007                 struct cmd_add_port_tm_node_shared_shaper_result,
1008                         shared_shaper_id, UINT32);
1009 cmdline_parse_token_num_t cmd_add_port_tm_node_shared_shaper_shaper_profile_id =
1010         TOKEN_NUM_INITIALIZER(
1011                 struct cmd_add_port_tm_node_shared_shaper_result,
1012                         shaper_profile_id, UINT32);
1013
1014 static void cmd_add_port_tm_node_shared_shaper_parsed(void *parsed_result,
1015         __attribute__((unused)) struct cmdline *cl,
1016         __attribute__((unused)) void *data)
1017 {
1018         struct cmd_add_port_tm_node_shared_shaper_result *res = parsed_result;
1019         struct rte_tm_error error;
1020         uint32_t shared_shaper_id = res->shared_shaper_id;
1021         uint32_t shaper_profile_id = res->shaper_profile_id;
1022         portid_t port_id = res->port_id;
1023         int ret;
1024
1025         if (port_id_is_invalid(port_id, ENABLED_WARN))
1026                 return;
1027
1028         memset(&error, 0, sizeof(struct rte_tm_error));
1029         /* Command type: add */
1030         if ((strcmp(res->cmd_type, "add") == 0) &&
1031                 (port_is_started(port_id))) {
1032                 printf(" Port %u not stopped (error)\n", port_id);
1033                 return;
1034         }
1035
1036         /* Command type: set (update) */
1037         if ((strcmp(res->cmd_type, "set") == 0) &&
1038                 (!port_is_started(port_id))) {
1039                 printf(" Port %u not started (error)\n", port_id);
1040                 return;
1041         }
1042
1043         ret = rte_tm_shared_shaper_add_update(port_id, shared_shaper_id,
1044                 shaper_profile_id, &error);
1045         if (ret != 0) {
1046                 print_err_msg(&error);
1047                 return;
1048         }
1049 }
1050
1051 cmdline_parse_inst_t cmd_add_port_tm_node_shared_shaper = {
1052         .f = cmd_add_port_tm_node_shared_shaper_parsed,
1053         .data = NULL,
1054         .help_str = "add/update port tm node shared shaper",
1055         .tokens = {
1056                 (void *)&cmd_add_port_tm_node_shared_shaper_cmd_type,
1057                 (void *)&cmd_add_port_tm_node_shared_shaper_port,
1058                 (void *)&cmd_add_port_tm_node_shared_shaper_tm,
1059                 (void *)&cmd_add_port_tm_node_shared_shaper_node,
1060                 (void *)&cmd_add_port_tm_node_shared_shaper_shared,
1061                 (void *)&cmd_add_port_tm_node_shared_shaper_shaper,
1062                 (void *)&cmd_add_port_tm_node_shared_shaper_port_id,
1063                 (void *)&cmd_add_port_tm_node_shared_shaper_shared_shaper_id,
1064                 (void *)&cmd_add_port_tm_node_shared_shaper_shaper_profile_id,
1065                 NULL,
1066         },
1067 };
1068
1069 /* *** Delete Port TM shared Shaper *** */
1070 struct cmd_del_port_tm_node_shared_shaper_result {
1071         cmdline_fixed_string_t del;
1072         cmdline_fixed_string_t port;
1073         cmdline_fixed_string_t tm;
1074         cmdline_fixed_string_t node;
1075         cmdline_fixed_string_t shared;
1076         cmdline_fixed_string_t shaper;
1077         uint16_t port_id;
1078         uint32_t shared_shaper_id;
1079 };
1080
1081 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_del =
1082         TOKEN_STRING_INITIALIZER(
1083                 struct cmd_del_port_tm_node_shared_shaper_result, del, "del");
1084 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_port =
1085         TOKEN_STRING_INITIALIZER(
1086                 struct cmd_del_port_tm_node_shared_shaper_result, port, "port");
1087 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_tm =
1088         TOKEN_STRING_INITIALIZER(
1089                 struct cmd_del_port_tm_node_shared_shaper_result, tm, "tm");
1090 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_node =
1091         TOKEN_STRING_INITIALIZER(
1092                 struct cmd_del_port_tm_node_shared_shaper_result, node, "node");
1093 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_shared =
1094         TOKEN_STRING_INITIALIZER(
1095                 struct cmd_del_port_tm_node_shared_shaper_result,
1096                         shared, "shared");
1097 cmdline_parse_token_string_t cmd_del_port_tm_node_shared_shaper_shaper =
1098         TOKEN_STRING_INITIALIZER(
1099                 struct cmd_del_port_tm_node_shared_shaper_result,
1100                         shaper, "shaper");
1101 cmdline_parse_token_num_t cmd_del_port_tm_node_shared_shaper_port_id =
1102         TOKEN_NUM_INITIALIZER(
1103                 struct cmd_del_port_tm_node_shared_shaper_result,
1104                         port_id, UINT16);
1105 cmdline_parse_token_num_t cmd_del_port_tm_node_shared_shaper_shared_shaper_id =
1106         TOKEN_NUM_INITIALIZER(
1107                 struct cmd_del_port_tm_node_shared_shaper_result,
1108                         shared_shaper_id, UINT32);
1109
1110 static void cmd_del_port_tm_node_shared_shaper_parsed(void *parsed_result,
1111         __attribute__((unused)) struct cmdline *cl,
1112         __attribute__((unused)) void *data)
1113 {
1114         struct cmd_del_port_tm_node_shared_shaper_result *res = parsed_result;
1115         struct rte_tm_error error;
1116         uint32_t shared_shaper_id = res->shared_shaper_id;
1117         portid_t port_id = res->port_id;
1118         int ret;
1119
1120         if (port_id_is_invalid(port_id, ENABLED_WARN))
1121                 return;
1122
1123         memset(&error, 0, sizeof(struct rte_tm_error));
1124         ret = rte_tm_shared_shaper_delete(port_id, shared_shaper_id, &error);
1125         if (ret != 0) {
1126                 print_err_msg(&error);
1127                 return;
1128         }
1129 }
1130
1131 cmdline_parse_inst_t cmd_del_port_tm_node_shared_shaper = {
1132         .f = cmd_del_port_tm_node_shared_shaper_parsed,
1133         .data = NULL,
1134         .help_str = "delete port tm node shared shaper",
1135         .tokens = {
1136                 (void *)&cmd_del_port_tm_node_shared_shaper_del,
1137                 (void *)&cmd_del_port_tm_node_shared_shaper_port,
1138                 (void *)&cmd_del_port_tm_node_shared_shaper_tm,
1139                 (void *)&cmd_del_port_tm_node_shared_shaper_node,
1140                 (void *)&cmd_del_port_tm_node_shared_shaper_shared,
1141                 (void *)&cmd_del_port_tm_node_shared_shaper_shaper,
1142                 (void *)&cmd_del_port_tm_node_shared_shaper_port_id,
1143                 (void *)&cmd_del_port_tm_node_shared_shaper_shared_shaper_id,
1144                 NULL,
1145         },
1146 };
1147
1148 /* *** Add Port TM Node WRED Profile *** */
1149 struct cmd_add_port_tm_node_wred_profile_result {
1150         cmdline_fixed_string_t add;
1151         cmdline_fixed_string_t port;
1152         cmdline_fixed_string_t tm;
1153         cmdline_fixed_string_t node;
1154         cmdline_fixed_string_t wred;
1155         cmdline_fixed_string_t profile;
1156         uint16_t port_id;
1157         uint32_t wred_profile_id;
1158         cmdline_fixed_string_t color_g;
1159         uint64_t min_th_g;
1160         uint64_t max_th_g;
1161         uint16_t maxp_inv_g;
1162         uint16_t wq_log2_g;
1163         cmdline_fixed_string_t color_y;
1164         uint64_t min_th_y;
1165         uint64_t max_th_y;
1166         uint16_t maxp_inv_y;
1167         uint16_t wq_log2_y;
1168         cmdline_fixed_string_t color_r;
1169         uint64_t min_th_r;
1170         uint64_t max_th_r;
1171         uint16_t maxp_inv_r;
1172         uint16_t wq_log2_r;
1173 };
1174
1175 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_add =
1176         TOKEN_STRING_INITIALIZER(
1177                 struct cmd_add_port_tm_node_wred_profile_result, add, "add");
1178 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_port =
1179         TOKEN_STRING_INITIALIZER(
1180                 struct cmd_add_port_tm_node_wred_profile_result, port, "port");
1181 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_tm =
1182         TOKEN_STRING_INITIALIZER(
1183                 struct cmd_add_port_tm_node_wred_profile_result, tm, "tm");
1184 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_node =
1185         TOKEN_STRING_INITIALIZER(
1186                 struct cmd_add_port_tm_node_wred_profile_result, node, "node");
1187 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_wred =
1188         TOKEN_STRING_INITIALIZER(
1189                 struct cmd_add_port_tm_node_wred_profile_result, wred, "wred");
1190 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_profile =
1191         TOKEN_STRING_INITIALIZER(
1192                 struct cmd_add_port_tm_node_wred_profile_result,
1193                         profile, "profile");
1194 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_port_id =
1195         TOKEN_NUM_INITIALIZER(
1196                 struct cmd_add_port_tm_node_wred_profile_result,
1197                         port_id, UINT16);
1198 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_wred_profile_id =
1199         TOKEN_NUM_INITIALIZER(
1200                 struct cmd_add_port_tm_node_wred_profile_result,
1201                         wred_profile_id, UINT32);
1202 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_color_g =
1203         TOKEN_STRING_INITIALIZER(
1204                 struct cmd_add_port_tm_node_wred_profile_result,
1205                         color_g, "G#g");
1206 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_min_th_g =
1207         TOKEN_NUM_INITIALIZER(
1208                 struct cmd_add_port_tm_node_wred_profile_result,
1209                         min_th_g, UINT64);
1210 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_max_th_g =
1211         TOKEN_NUM_INITIALIZER(
1212                 struct cmd_add_port_tm_node_wred_profile_result,
1213                         max_th_g, UINT64);
1214 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_maxp_inv_g =
1215         TOKEN_NUM_INITIALIZER(
1216                 struct cmd_add_port_tm_node_wred_profile_result,
1217                         maxp_inv_g, UINT16);
1218 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_wq_log2_g =
1219         TOKEN_NUM_INITIALIZER(
1220                 struct cmd_add_port_tm_node_wred_profile_result,
1221                         wq_log2_g, UINT16);
1222 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_color_y =
1223         TOKEN_STRING_INITIALIZER(
1224                 struct cmd_add_port_tm_node_wred_profile_result,
1225                         color_y, "Y#y");
1226 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_min_th_y =
1227         TOKEN_NUM_INITIALIZER(
1228                 struct cmd_add_port_tm_node_wred_profile_result,
1229                         min_th_y, UINT64);
1230 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_max_th_y =
1231         TOKEN_NUM_INITIALIZER(
1232                 struct cmd_add_port_tm_node_wred_profile_result,
1233                         max_th_y, UINT64);
1234 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_maxp_inv_y =
1235         TOKEN_NUM_INITIALIZER(
1236                 struct cmd_add_port_tm_node_wred_profile_result,
1237                         maxp_inv_y, UINT16);
1238 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_wq_log2_y =
1239         TOKEN_NUM_INITIALIZER(
1240                 struct cmd_add_port_tm_node_wred_profile_result,
1241                         wq_log2_y, UINT16);
1242 cmdline_parse_token_string_t cmd_add_port_tm_node_wred_profile_color_r =
1243         TOKEN_STRING_INITIALIZER(
1244                 struct cmd_add_port_tm_node_wred_profile_result,
1245                         color_r, "R#r");
1246 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_min_th_r =
1247         TOKEN_NUM_INITIALIZER(
1248                 struct cmd_add_port_tm_node_wred_profile_result,
1249                         min_th_r, UINT64);
1250 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_max_th_r =
1251         TOKEN_NUM_INITIALIZER(
1252                 struct cmd_add_port_tm_node_wred_profile_result,
1253                         max_th_r, UINT64);
1254 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_maxp_inv_r =
1255         TOKEN_NUM_INITIALIZER(
1256                 struct cmd_add_port_tm_node_wred_profile_result,
1257                         maxp_inv_r, UINT16);
1258 cmdline_parse_token_num_t cmd_add_port_tm_node_wred_profile_wq_log2_r =
1259         TOKEN_NUM_INITIALIZER(
1260                 struct cmd_add_port_tm_node_wred_profile_result,
1261                         wq_log2_r, UINT16);
1262
1263
1264 static void cmd_add_port_tm_node_wred_profile_parsed(void *parsed_result,
1265         __attribute__((unused)) struct cmdline *cl,
1266         __attribute__((unused)) void *data)
1267 {
1268         struct cmd_add_port_tm_node_wred_profile_result *res = parsed_result;
1269         struct rte_tm_wred_params wp;
1270         enum rte_color color;
1271         struct rte_tm_error error;
1272         uint32_t wred_profile_id = res->wred_profile_id;
1273         portid_t port_id = res->port_id;
1274         int ret;
1275
1276         if (port_id_is_invalid(port_id, ENABLED_WARN))
1277                 return;
1278
1279         memset(&wp, 0, sizeof(struct rte_tm_wred_params));
1280         memset(&error, 0, sizeof(struct rte_tm_error));
1281
1282         /* WRED Params  (Green Color)*/
1283         color = RTE_COLOR_GREEN;
1284         wp.red_params[color].min_th = res->min_th_g;
1285         wp.red_params[color].max_th = res->max_th_g;
1286         wp.red_params[color].maxp_inv = res->maxp_inv_g;
1287         wp.red_params[color].wq_log2 = res->wq_log2_g;
1288
1289
1290         /* WRED Params  (Yellow Color)*/
1291         color = RTE_COLOR_YELLOW;
1292         wp.red_params[color].min_th = res->min_th_y;
1293         wp.red_params[color].max_th = res->max_th_y;
1294         wp.red_params[color].maxp_inv = res->maxp_inv_y;
1295         wp.red_params[color].wq_log2 = res->wq_log2_y;
1296
1297         /* WRED Params  (Red Color)*/
1298         color = RTE_COLOR_RED;
1299         wp.red_params[color].min_th = res->min_th_r;
1300         wp.red_params[color].max_th = res->max_th_r;
1301         wp.red_params[color].maxp_inv = res->maxp_inv_r;
1302         wp.red_params[color].wq_log2 = res->wq_log2_r;
1303
1304         ret = rte_tm_wred_profile_add(port_id, wred_profile_id, &wp, &error);
1305         if (ret != 0) {
1306                 print_err_msg(&error);
1307                 return;
1308         }
1309 }
1310
1311 cmdline_parse_inst_t cmd_add_port_tm_node_wred_profile = {
1312         .f = cmd_add_port_tm_node_wred_profile_parsed,
1313         .data = NULL,
1314         .help_str = "Add port tm node wred profile",
1315         .tokens = {
1316                 (void *)&cmd_add_port_tm_node_wred_profile_add,
1317                 (void *)&cmd_add_port_tm_node_wred_profile_port,
1318                 (void *)&cmd_add_port_tm_node_wred_profile_tm,
1319                 (void *)&cmd_add_port_tm_node_wred_profile_node,
1320                 (void *)&cmd_add_port_tm_node_wred_profile_wred,
1321                 (void *)&cmd_add_port_tm_node_wred_profile_profile,
1322                 (void *)&cmd_add_port_tm_node_wred_profile_port_id,
1323                 (void *)&cmd_add_port_tm_node_wred_profile_wred_profile_id,
1324                 (void *)&cmd_add_port_tm_node_wred_profile_color_g,
1325                 (void *)&cmd_add_port_tm_node_wred_profile_min_th_g,
1326                 (void *)&cmd_add_port_tm_node_wred_profile_max_th_g,
1327                 (void *)&cmd_add_port_tm_node_wred_profile_maxp_inv_g,
1328                 (void *)&cmd_add_port_tm_node_wred_profile_wq_log2_g,
1329                 (void *)&cmd_add_port_tm_node_wred_profile_color_y,
1330                 (void *)&cmd_add_port_tm_node_wred_profile_min_th_y,
1331                 (void *)&cmd_add_port_tm_node_wred_profile_max_th_y,
1332                 (void *)&cmd_add_port_tm_node_wred_profile_maxp_inv_y,
1333                 (void *)&cmd_add_port_tm_node_wred_profile_wq_log2_y,
1334                 (void *)&cmd_add_port_tm_node_wred_profile_color_r,
1335                 (void *)&cmd_add_port_tm_node_wred_profile_min_th_r,
1336                 (void *)&cmd_add_port_tm_node_wred_profile_max_th_r,
1337                 (void *)&cmd_add_port_tm_node_wred_profile_maxp_inv_r,
1338                 (void *)&cmd_add_port_tm_node_wred_profile_wq_log2_r,
1339                 NULL,
1340         },
1341 };
1342
1343 /* *** Delete Port TM node WRED Profile *** */
1344 struct cmd_del_port_tm_node_wred_profile_result {
1345         cmdline_fixed_string_t del;
1346         cmdline_fixed_string_t port;
1347         cmdline_fixed_string_t tm;
1348         cmdline_fixed_string_t node;
1349         cmdline_fixed_string_t wred;
1350         cmdline_fixed_string_t profile;
1351         uint16_t port_id;
1352         uint32_t wred_profile_id;
1353 };
1354
1355 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_del =
1356         TOKEN_STRING_INITIALIZER(
1357                 struct cmd_del_port_tm_node_wred_profile_result, del, "del");
1358 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_port =
1359         TOKEN_STRING_INITIALIZER(
1360                 struct cmd_del_port_tm_node_wred_profile_result, port, "port");
1361 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_tm =
1362         TOKEN_STRING_INITIALIZER(
1363                 struct cmd_del_port_tm_node_wred_profile_result, tm, "tm");
1364 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_node =
1365         TOKEN_STRING_INITIALIZER(
1366                 struct cmd_del_port_tm_node_wred_profile_result, node, "node");
1367 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_wred =
1368         TOKEN_STRING_INITIALIZER(
1369                 struct cmd_del_port_tm_node_wred_profile_result, wred, "wred");
1370 cmdline_parse_token_string_t cmd_del_port_tm_node_wred_profile_profile =
1371         TOKEN_STRING_INITIALIZER(
1372                 struct cmd_del_port_tm_node_wred_profile_result,
1373                         profile, "profile");
1374 cmdline_parse_token_num_t cmd_del_port_tm_node_wred_profile_port_id =
1375         TOKEN_NUM_INITIALIZER(
1376                 struct cmd_del_port_tm_node_wred_profile_result,
1377                         port_id, UINT16);
1378 cmdline_parse_token_num_t cmd_del_port_tm_node_wred_profile_wred_profile_id =
1379         TOKEN_NUM_INITIALIZER(
1380                 struct cmd_del_port_tm_node_wred_profile_result,
1381                         wred_profile_id, UINT32);
1382
1383 static void cmd_del_port_tm_node_wred_profile_parsed(void *parsed_result,
1384         __attribute__((unused)) struct cmdline *cl,
1385         __attribute__((unused)) void *data)
1386 {
1387         struct cmd_del_port_tm_node_wred_profile_result *res = parsed_result;
1388         struct rte_tm_error error;
1389         uint32_t wred_profile_id = res->wred_profile_id;
1390         portid_t port_id = res->port_id;
1391         int ret;
1392
1393         if (port_id_is_invalid(port_id, ENABLED_WARN))
1394                 return;
1395
1396         memset(&error, 0, sizeof(struct rte_tm_error));
1397         ret = rte_tm_wred_profile_delete(port_id, wred_profile_id, &error);
1398         if (ret != 0) {
1399                 print_err_msg(&error);
1400                 return;
1401         }
1402 }
1403
1404 cmdline_parse_inst_t cmd_del_port_tm_node_wred_profile = {
1405         .f = cmd_del_port_tm_node_wred_profile_parsed,
1406         .data = NULL,
1407         .help_str = "Delete port tm node wred profile",
1408         .tokens = {
1409                 (void *)&cmd_del_port_tm_node_wred_profile_del,
1410                 (void *)&cmd_del_port_tm_node_wred_profile_port,
1411                 (void *)&cmd_del_port_tm_node_wred_profile_tm,
1412                 (void *)&cmd_del_port_tm_node_wred_profile_node,
1413                 (void *)&cmd_del_port_tm_node_wred_profile_wred,
1414                 (void *)&cmd_del_port_tm_node_wred_profile_profile,
1415                 (void *)&cmd_del_port_tm_node_wred_profile_port_id,
1416                 (void *)&cmd_del_port_tm_node_wred_profile_wred_profile_id,
1417                 NULL,
1418         },
1419 };
1420
1421 /* *** Update Port TM Node Shaper profile *** */
1422 struct cmd_set_port_tm_node_shaper_profile_result {
1423         cmdline_fixed_string_t set;
1424         cmdline_fixed_string_t port;
1425         cmdline_fixed_string_t tm;
1426         cmdline_fixed_string_t node;
1427         cmdline_fixed_string_t shaper;
1428         cmdline_fixed_string_t profile;
1429         uint16_t port_id;
1430         uint32_t node_id;
1431         uint32_t shaper_profile_id;
1432 };
1433
1434 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_set =
1435         TOKEN_STRING_INITIALIZER(
1436                 struct cmd_set_port_tm_node_shaper_profile_result, set, "set");
1437 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_port =
1438         TOKEN_STRING_INITIALIZER(
1439                 struct cmd_set_port_tm_node_shaper_profile_result,
1440                         port, "port");
1441 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_tm =
1442         TOKEN_STRING_INITIALIZER(
1443                 struct cmd_set_port_tm_node_shaper_profile_result, tm, "tm");
1444 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_node =
1445         TOKEN_STRING_INITIALIZER(
1446                 struct cmd_set_port_tm_node_shaper_profile_result,
1447                         node, "node");
1448 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_shaper =
1449         TOKEN_STRING_INITIALIZER(
1450                 struct cmd_set_port_tm_node_shaper_profile_result,
1451                         shaper, "shaper");
1452 cmdline_parse_token_string_t cmd_set_port_tm_node_shaper_profile_profile =
1453         TOKEN_STRING_INITIALIZER(
1454                 struct cmd_set_port_tm_node_shaper_profile_result,
1455                         profile, "profile");
1456 cmdline_parse_token_num_t cmd_set_port_tm_node_shaper_profile_port_id =
1457         TOKEN_NUM_INITIALIZER(
1458                 struct cmd_set_port_tm_node_shaper_profile_result,
1459                         port_id, UINT16);
1460 cmdline_parse_token_num_t cmd_set_port_tm_node_shaper_profile_node_id =
1461         TOKEN_NUM_INITIALIZER(struct cmd_set_port_tm_node_shaper_profile_result,
1462                 node_id, UINT32);
1463 cmdline_parse_token_num_t
1464         cmd_set_port_tm_node_shaper_shaper_profile_profile_id =
1465                 TOKEN_NUM_INITIALIZER(
1466                         struct cmd_set_port_tm_node_shaper_profile_result,
1467                         shaper_profile_id, UINT32);
1468
1469 static void cmd_set_port_tm_node_shaper_profile_parsed(void *parsed_result,
1470         __attribute__((unused)) struct cmdline *cl,
1471         __attribute__((unused)) void *data)
1472 {
1473         struct cmd_set_port_tm_node_shaper_profile_result *res = parsed_result;
1474         struct rte_tm_error error;
1475         uint32_t node_id = res->node_id;
1476         uint32_t shaper_profile_id = res->shaper_profile_id;
1477         portid_t port_id = res->port_id;
1478         int ret;
1479
1480         if (port_id_is_invalid(port_id, ENABLED_WARN))
1481                 return;
1482
1483         memset(&error, 0, sizeof(struct rte_tm_error));
1484         /* Port status */
1485         if (!port_is_started(port_id)) {
1486                 printf(" Port %u not started (error)\n", port_id);
1487                 return;
1488         }
1489
1490         ret = rte_tm_node_shaper_update(port_id, node_id,
1491                 shaper_profile_id, &error);
1492         if (ret != 0) {
1493                 print_err_msg(&error);
1494                 return;
1495         }
1496 }
1497
1498 cmdline_parse_inst_t cmd_set_port_tm_node_shaper_profile = {
1499         .f = cmd_set_port_tm_node_shaper_profile_parsed,
1500         .data = NULL,
1501         .help_str = "Set port tm node shaper profile",
1502         .tokens = {
1503                 (void *)&cmd_set_port_tm_node_shaper_profile_set,
1504                 (void *)&cmd_set_port_tm_node_shaper_profile_port,
1505                 (void *)&cmd_set_port_tm_node_shaper_profile_tm,
1506                 (void *)&cmd_set_port_tm_node_shaper_profile_node,
1507                 (void *)&cmd_set_port_tm_node_shaper_profile_shaper,
1508                 (void *)&cmd_set_port_tm_node_shaper_profile_profile,
1509                 (void *)&cmd_set_port_tm_node_shaper_profile_port_id,
1510                 (void *)&cmd_set_port_tm_node_shaper_profile_node_id,
1511                 (void *)&cmd_set_port_tm_node_shaper_shaper_profile_profile_id,
1512                 NULL,
1513         },
1514 };
1515
1516 /* *** Add Port TM nonleaf node *** */
1517 struct cmd_add_port_tm_nonleaf_node_result {
1518         cmdline_fixed_string_t add;
1519         cmdline_fixed_string_t port;
1520         cmdline_fixed_string_t tm;
1521         cmdline_fixed_string_t nonleaf;
1522         cmdline_fixed_string_t node;
1523         uint16_t port_id;
1524         uint32_t node_id;
1525         int32_t parent_node_id;
1526         uint32_t priority;
1527         uint32_t weight;
1528         uint32_t level_id;
1529         int32_t shaper_profile_id;
1530         uint32_t n_sp_priorities;
1531         uint64_t stats_mask;
1532         cmdline_multi_string_t multi_shared_shaper_id;
1533 };
1534
1535 cmdline_parse_token_string_t cmd_add_port_tm_nonleaf_node_add =
1536         TOKEN_STRING_INITIALIZER(
1537                 struct cmd_add_port_tm_nonleaf_node_result, add, "add");
1538 cmdline_parse_token_string_t cmd_add_port_tm_nonleaf_node_port =
1539         TOKEN_STRING_INITIALIZER(
1540                 struct cmd_add_port_tm_nonleaf_node_result, port, "port");
1541 cmdline_parse_token_string_t cmd_add_port_tm_nonleaf_node_tm =
1542         TOKEN_STRING_INITIALIZER(
1543                 struct cmd_add_port_tm_nonleaf_node_result, tm, "tm");
1544 cmdline_parse_token_string_t cmd_add_port_tm_nonleaf_node_nonleaf =
1545         TOKEN_STRING_INITIALIZER(
1546                 struct cmd_add_port_tm_nonleaf_node_result, nonleaf, "nonleaf");
1547 cmdline_parse_token_string_t cmd_add_port_tm_nonleaf_node_node =
1548         TOKEN_STRING_INITIALIZER(
1549                 struct cmd_add_port_tm_nonleaf_node_result, node, "node");
1550 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_port_id =
1551         TOKEN_NUM_INITIALIZER(
1552                 struct cmd_add_port_tm_nonleaf_node_result,
1553                  port_id, UINT16);
1554 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_node_id =
1555         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1556                  node_id, UINT32);
1557 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_parent_node_id =
1558         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1559                  parent_node_id, INT32);
1560 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_priority =
1561         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1562                  priority, UINT32);
1563 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_weight =
1564         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1565                  weight, UINT32);
1566 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_level_id =
1567         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1568                  level_id, UINT32);
1569 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_shaper_profile_id =
1570         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1571                  shaper_profile_id, INT32);
1572 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_n_sp_priorities =
1573         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1574                  n_sp_priorities, UINT32);
1575 cmdline_parse_token_num_t cmd_add_port_tm_nonleaf_node_stats_mask =
1576         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1577                  stats_mask, UINT64);
1578 cmdline_parse_token_string_t
1579         cmd_add_port_tm_nonleaf_node_multi_shared_shaper_id =
1580         TOKEN_STRING_INITIALIZER(struct cmd_add_port_tm_nonleaf_node_result,
1581                  multi_shared_shaper_id, TOKEN_STRING_MULTI);
1582
1583 static void cmd_add_port_tm_nonleaf_node_parsed(void *parsed_result,
1584         __attribute__((unused)) struct cmdline *cl,
1585         __attribute__((unused)) void *data)
1586 {
1587         struct cmd_add_port_tm_nonleaf_node_result *res = parsed_result;
1588         struct rte_tm_error error;
1589         struct rte_tm_node_params np;
1590         uint32_t *shared_shaper_id;
1591         uint32_t parent_node_id, n_shared_shapers = 0;
1592         char *s_str = res->multi_shared_shaper_id;
1593         portid_t port_id = res->port_id;
1594         int ret;
1595
1596         if (port_id_is_invalid(port_id, ENABLED_WARN))
1597                 return;
1598
1599         memset(&np, 0, sizeof(struct rte_tm_node_params));
1600         memset(&error, 0, sizeof(struct rte_tm_error));
1601
1602         /* Node parameters */
1603         if (res->parent_node_id < 0)
1604                 parent_node_id = UINT32_MAX;
1605         else
1606                 parent_node_id = res->parent_node_id;
1607
1608         shared_shaper_id = (uint32_t *)malloc(MAX_NUM_SHARED_SHAPERS *
1609                 sizeof(uint32_t));
1610         if (shared_shaper_id == NULL) {
1611                 printf(" Memory not allocated for shared shapers (error)\n");
1612                 return;
1613         }
1614
1615         /* Parse multi shared shaper id string */
1616         ret = parse_multi_ss_id_str(s_str, &n_shared_shapers, shared_shaper_id);
1617         if (ret) {
1618                 printf(" Shared shapers params string parse error\n");
1619                 free(shared_shaper_id);
1620                 return;
1621         }
1622
1623         if (res->shaper_profile_id < 0)
1624                 np.shaper_profile_id = UINT32_MAX;
1625         else
1626                 np.shaper_profile_id = res->shaper_profile_id;
1627
1628         np.n_shared_shapers = n_shared_shapers;
1629         if (np.n_shared_shapers) {
1630                 np.shared_shaper_id = &shared_shaper_id[0];
1631         } else {
1632                 free(shared_shaper_id);
1633                 shared_shaper_id = NULL;
1634         }
1635
1636         np.nonleaf.n_sp_priorities = res->n_sp_priorities;
1637         np.stats_mask = res->stats_mask;
1638         np.nonleaf.wfq_weight_mode = NULL;
1639
1640         ret = rte_tm_node_add(port_id, res->node_id, parent_node_id,
1641                                 res->priority, res->weight, res->level_id,
1642                                 &np, &error);
1643         if (ret != 0) {
1644                 print_err_msg(&error);
1645                 free(shared_shaper_id);
1646                 return;
1647         }
1648 }
1649
1650 cmdline_parse_inst_t cmd_add_port_tm_nonleaf_node = {
1651         .f = cmd_add_port_tm_nonleaf_node_parsed,
1652         .data = NULL,
1653         .help_str = "Add port tm nonleaf node",
1654         .tokens = {
1655                 (void *)&cmd_add_port_tm_nonleaf_node_add,
1656                 (void *)&cmd_add_port_tm_nonleaf_node_port,
1657                 (void *)&cmd_add_port_tm_nonleaf_node_tm,
1658                 (void *)&cmd_add_port_tm_nonleaf_node_nonleaf,
1659                 (void *)&cmd_add_port_tm_nonleaf_node_node,
1660                 (void *)&cmd_add_port_tm_nonleaf_node_port_id,
1661                 (void *)&cmd_add_port_tm_nonleaf_node_node_id,
1662                 (void *)&cmd_add_port_tm_nonleaf_node_parent_node_id,
1663                 (void *)&cmd_add_port_tm_nonleaf_node_priority,
1664                 (void *)&cmd_add_port_tm_nonleaf_node_weight,
1665                 (void *)&cmd_add_port_tm_nonleaf_node_level_id,
1666                 (void *)&cmd_add_port_tm_nonleaf_node_shaper_profile_id,
1667                 (void *)&cmd_add_port_tm_nonleaf_node_n_sp_priorities,
1668                 (void *)&cmd_add_port_tm_nonleaf_node_stats_mask,
1669                 (void *)&cmd_add_port_tm_nonleaf_node_multi_shared_shaper_id,
1670                 NULL,
1671         },
1672 };
1673
1674 /* *** Add Port TM leaf node *** */
1675 struct cmd_add_port_tm_leaf_node_result {
1676         cmdline_fixed_string_t add;
1677         cmdline_fixed_string_t port;
1678         cmdline_fixed_string_t tm;
1679         cmdline_fixed_string_t leaf;
1680         cmdline_fixed_string_t node;
1681         uint16_t port_id;
1682         uint32_t node_id;
1683         int32_t parent_node_id;
1684         uint32_t priority;
1685         uint32_t weight;
1686         uint32_t level_id;
1687         int32_t shaper_profile_id;
1688         uint32_t cman_mode;
1689         uint32_t wred_profile_id;
1690         uint64_t stats_mask;
1691         cmdline_multi_string_t multi_shared_shaper_id;
1692 };
1693
1694 cmdline_parse_token_string_t cmd_add_port_tm_leaf_node_add =
1695         TOKEN_STRING_INITIALIZER(
1696                 struct cmd_add_port_tm_leaf_node_result, add, "add");
1697 cmdline_parse_token_string_t cmd_add_port_tm_leaf_node_port =
1698         TOKEN_STRING_INITIALIZER(
1699                 struct cmd_add_port_tm_leaf_node_result, port, "port");
1700 cmdline_parse_token_string_t cmd_add_port_tm_leaf_node_tm =
1701         TOKEN_STRING_INITIALIZER(
1702                 struct cmd_add_port_tm_leaf_node_result, tm, "tm");
1703 cmdline_parse_token_string_t cmd_add_port_tm_leaf_node_nonleaf =
1704         TOKEN_STRING_INITIALIZER(
1705                 struct cmd_add_port_tm_leaf_node_result, leaf, "leaf");
1706 cmdline_parse_token_string_t cmd_add_port_tm_leaf_node_node =
1707         TOKEN_STRING_INITIALIZER(
1708                 struct cmd_add_port_tm_leaf_node_result, node, "node");
1709 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_port_id =
1710         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1711                  port_id, UINT16);
1712 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_node_id =
1713         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1714                  node_id, UINT32);
1715 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_parent_node_id =
1716         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1717                  parent_node_id, INT32);
1718 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_priority =
1719         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1720                  priority, UINT32);
1721 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_weight =
1722         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1723                  weight, UINT32);
1724 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_level_id =
1725         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1726                  level_id, UINT32);
1727 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_shaper_profile_id =
1728         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1729                  shaper_profile_id, INT32);
1730 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_cman_mode =
1731         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1732                  cman_mode, UINT32);
1733 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_wred_profile_id =
1734         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1735                  wred_profile_id, UINT32);
1736 cmdline_parse_token_num_t cmd_add_port_tm_leaf_node_stats_mask =
1737         TOKEN_NUM_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1738                  stats_mask, UINT64);
1739 cmdline_parse_token_string_t
1740         cmd_add_port_tm_leaf_node_multi_shared_shaper_id =
1741         TOKEN_STRING_INITIALIZER(struct cmd_add_port_tm_leaf_node_result,
1742                  multi_shared_shaper_id, TOKEN_STRING_MULTI);
1743
1744 static void cmd_add_port_tm_leaf_node_parsed(void *parsed_result,
1745         __attribute__((unused)) struct cmdline *cl,
1746         __attribute__((unused)) void *data)
1747 {
1748         struct cmd_add_port_tm_leaf_node_result *res = parsed_result;
1749         struct rte_tm_error error;
1750         struct rte_tm_node_params np;
1751         uint32_t *shared_shaper_id;
1752         uint32_t parent_node_id, n_shared_shapers = 0;
1753         portid_t port_id = res->port_id;
1754         char *s_str = res->multi_shared_shaper_id;
1755         int ret;
1756
1757         if (port_id_is_invalid(port_id, ENABLED_WARN))
1758                 return;
1759
1760         memset(&np, 0, sizeof(struct rte_tm_node_params));
1761         memset(&error, 0, sizeof(struct rte_tm_error));
1762
1763         /* Node parameters */
1764         if (res->parent_node_id < 0)
1765                 parent_node_id = UINT32_MAX;
1766         else
1767                 parent_node_id = res->parent_node_id;
1768
1769         shared_shaper_id = (uint32_t *)malloc(MAX_NUM_SHARED_SHAPERS *
1770                 sizeof(uint32_t));
1771         if (shared_shaper_id == NULL) {
1772                 printf(" Memory not allocated for shared shapers (error)\n");
1773                 return;
1774         }
1775
1776         /* Parse multi shared shaper id string */
1777         ret = parse_multi_ss_id_str(s_str, &n_shared_shapers, shared_shaper_id);
1778         if (ret) {
1779                 printf(" Shared shapers params string parse error\n");
1780                 free(shared_shaper_id);
1781                 return;
1782         }
1783
1784         if (res->shaper_profile_id < 0)
1785                 np.shaper_profile_id = UINT32_MAX;
1786         else
1787                 np.shaper_profile_id = res->shaper_profile_id;
1788
1789         np.n_shared_shapers = n_shared_shapers;
1790
1791         if (np.n_shared_shapers) {
1792                 np.shared_shaper_id = &shared_shaper_id[0];
1793         } else {
1794                 free(shared_shaper_id);
1795                 shared_shaper_id = NULL;
1796         }
1797
1798         np.leaf.cman = res->cman_mode;
1799         np.leaf.wred.wred_profile_id = res->wred_profile_id;
1800         np.stats_mask = res->stats_mask;
1801
1802         ret = rte_tm_node_add(port_id, res->node_id, parent_node_id,
1803                                 res->priority, res->weight, res->level_id,
1804                                 &np, &error);
1805         if (ret != 0) {
1806                 print_err_msg(&error);
1807                 free(shared_shaper_id);
1808                 return;
1809         }
1810 }
1811
1812 cmdline_parse_inst_t cmd_add_port_tm_leaf_node = {
1813         .f = cmd_add_port_tm_leaf_node_parsed,
1814         .data = NULL,
1815         .help_str = "Add port tm leaf node",
1816         .tokens = {
1817                 (void *)&cmd_add_port_tm_leaf_node_add,
1818                 (void *)&cmd_add_port_tm_leaf_node_port,
1819                 (void *)&cmd_add_port_tm_leaf_node_tm,
1820                 (void *)&cmd_add_port_tm_leaf_node_nonleaf,
1821                 (void *)&cmd_add_port_tm_leaf_node_node,
1822                 (void *)&cmd_add_port_tm_leaf_node_port_id,
1823                 (void *)&cmd_add_port_tm_leaf_node_node_id,
1824                 (void *)&cmd_add_port_tm_leaf_node_parent_node_id,
1825                 (void *)&cmd_add_port_tm_leaf_node_priority,
1826                 (void *)&cmd_add_port_tm_leaf_node_weight,
1827                 (void *)&cmd_add_port_tm_leaf_node_level_id,
1828                 (void *)&cmd_add_port_tm_leaf_node_shaper_profile_id,
1829                 (void *)&cmd_add_port_tm_leaf_node_cman_mode,
1830                 (void *)&cmd_add_port_tm_leaf_node_wred_profile_id,
1831                 (void *)&cmd_add_port_tm_leaf_node_stats_mask,
1832                 (void *)&cmd_add_port_tm_leaf_node_multi_shared_shaper_id,
1833                 NULL,
1834         },
1835 };
1836
1837 /* *** Delete Port TM Node *** */
1838 struct cmd_del_port_tm_node_result {
1839         cmdline_fixed_string_t del;
1840         cmdline_fixed_string_t port;
1841         cmdline_fixed_string_t tm;
1842         cmdline_fixed_string_t node;
1843         uint16_t port_id;
1844         uint32_t node_id;
1845 };
1846
1847 cmdline_parse_token_string_t cmd_del_port_tm_node_del =
1848         TOKEN_STRING_INITIALIZER(
1849                 struct cmd_del_port_tm_node_result, del, "del");
1850 cmdline_parse_token_string_t cmd_del_port_tm_node_port =
1851         TOKEN_STRING_INITIALIZER(
1852                 struct cmd_del_port_tm_node_result, port, "port");
1853 cmdline_parse_token_string_t cmd_del_port_tm_node_tm =
1854         TOKEN_STRING_INITIALIZER(
1855                 struct cmd_del_port_tm_node_result, tm, "tm");
1856 cmdline_parse_token_string_t cmd_del_port_tm_node_node =
1857         TOKEN_STRING_INITIALIZER(
1858                 struct cmd_del_port_tm_node_result, node, "node");
1859 cmdline_parse_token_num_t cmd_del_port_tm_node_port_id =
1860         TOKEN_NUM_INITIALIZER(struct cmd_del_port_tm_node_result,
1861                  port_id, UINT16);
1862 cmdline_parse_token_num_t cmd_del_port_tm_node_node_id =
1863         TOKEN_NUM_INITIALIZER(struct cmd_del_port_tm_node_result,
1864                 node_id, UINT32);
1865
1866 static void cmd_del_port_tm_node_parsed(void *parsed_result,
1867         __attribute__((unused)) struct cmdline *cl,
1868         __attribute__((unused)) void *data)
1869 {
1870         struct cmd_del_port_tm_node_result *res = parsed_result;
1871         struct rte_tm_error error;
1872         uint32_t node_id = res->node_id;
1873         portid_t port_id = res->port_id;
1874         int ret;
1875
1876         if (port_id_is_invalid(port_id, ENABLED_WARN))
1877                 return;
1878
1879         memset(&error, 0, sizeof(struct rte_tm_error));
1880         /* Port status */
1881         if (port_is_started(port_id)) {
1882                 printf(" Port %u not stopped (error)\n", port_id);
1883                 return;
1884         }
1885
1886         ret = rte_tm_node_delete(port_id, node_id, &error);
1887         if (ret != 0) {
1888                 print_err_msg(&error);
1889                 return;
1890         }
1891 }
1892
1893 cmdline_parse_inst_t cmd_del_port_tm_node = {
1894         .f = cmd_del_port_tm_node_parsed,
1895         .data = NULL,
1896         .help_str = "Delete port tm node",
1897         .tokens = {
1898                 (void *)&cmd_del_port_tm_node_del,
1899                 (void *)&cmd_del_port_tm_node_port,
1900                 (void *)&cmd_del_port_tm_node_tm,
1901                 (void *)&cmd_del_port_tm_node_node,
1902                 (void *)&cmd_del_port_tm_node_port_id,
1903                 (void *)&cmd_del_port_tm_node_node_id,
1904                 NULL,
1905         },
1906 };
1907
1908 /* *** Update Port TM Node Parent *** */
1909 struct cmd_set_port_tm_node_parent_result {
1910         cmdline_fixed_string_t set;
1911         cmdline_fixed_string_t port;
1912         cmdline_fixed_string_t tm;
1913         cmdline_fixed_string_t node;
1914         cmdline_fixed_string_t parent;
1915         uint16_t port_id;
1916         uint32_t node_id;
1917         uint32_t parent_id;
1918         uint32_t priority;
1919         uint32_t weight;
1920 };
1921
1922 cmdline_parse_token_string_t cmd_set_port_tm_node_parent_set =
1923         TOKEN_STRING_INITIALIZER(
1924                 struct cmd_set_port_tm_node_parent_result, set, "set");
1925 cmdline_parse_token_string_t cmd_set_port_tm_node_parent_port =
1926         TOKEN_STRING_INITIALIZER(
1927                 struct cmd_set_port_tm_node_parent_result, port, "port");
1928 cmdline_parse_token_string_t cmd_set_port_tm_node_parent_tm =
1929         TOKEN_STRING_INITIALIZER(
1930                 struct cmd_set_port_tm_node_parent_result, tm, "tm");
1931 cmdline_parse_token_string_t cmd_set_port_tm_node_parent_node =
1932         TOKEN_STRING_INITIALIZER(
1933                 struct cmd_set_port_tm_node_parent_result, node, "node");
1934 cmdline_parse_token_string_t cmd_set_port_tm_node_parent_parent =
1935         TOKEN_STRING_INITIALIZER(
1936                 struct cmd_set_port_tm_node_parent_result, parent, "parent");
1937 cmdline_parse_token_num_t cmd_set_port_tm_node_parent_port_id =
1938         TOKEN_NUM_INITIALIZER(
1939                 struct cmd_set_port_tm_node_parent_result, port_id, UINT16);
1940 cmdline_parse_token_num_t cmd_set_port_tm_node_parent_node_id =
1941         TOKEN_NUM_INITIALIZER(
1942                 struct cmd_set_port_tm_node_parent_result, node_id, UINT32);
1943 cmdline_parse_token_num_t cmd_set_port_tm_node_parent_parent_id =
1944         TOKEN_NUM_INITIALIZER(struct cmd_set_port_tm_node_parent_result,
1945                 parent_id, UINT32);
1946 cmdline_parse_token_num_t cmd_set_port_tm_node_parent_priority =
1947         TOKEN_NUM_INITIALIZER(struct cmd_set_port_tm_node_parent_result,
1948                 priority, UINT32);
1949 cmdline_parse_token_num_t cmd_set_port_tm_node_parent_weight =
1950         TOKEN_NUM_INITIALIZER(struct cmd_set_port_tm_node_parent_result,
1951                 weight, UINT32);
1952
1953 static void cmd_set_port_tm_node_parent_parsed(void *parsed_result,
1954         __attribute__((unused)) struct cmdline *cl,
1955         __attribute__((unused)) void *data)
1956 {
1957         struct cmd_set_port_tm_node_parent_result *res = parsed_result;
1958         struct rte_tm_error error;
1959         uint32_t node_id = res->node_id;
1960         uint32_t parent_id = res->parent_id;
1961         uint32_t priority = res->priority;
1962         uint32_t weight = res->weight;
1963         portid_t port_id = res->port_id;
1964         int ret;
1965
1966         if (port_id_is_invalid(port_id, ENABLED_WARN))
1967                 return;
1968
1969         memset(&error, 0, sizeof(struct rte_tm_error));
1970         /* Port status */
1971         if (!port_is_started(port_id)) {
1972                 printf(" Port %u not started (error)\n", port_id);
1973                 return;
1974         }
1975
1976         ret = rte_tm_node_parent_update(port_id, node_id,
1977                 parent_id, priority, weight, &error);
1978         if (ret != 0) {
1979                 print_err_msg(&error);
1980                 return;
1981         }
1982 }
1983
1984 cmdline_parse_inst_t cmd_set_port_tm_node_parent = {
1985         .f = cmd_set_port_tm_node_parent_parsed,
1986         .data = NULL,
1987         .help_str = "Set port tm node parent",
1988         .tokens = {
1989                 (void *)&cmd_set_port_tm_node_parent_set,
1990                 (void *)&cmd_set_port_tm_node_parent_port,
1991                 (void *)&cmd_set_port_tm_node_parent_tm,
1992                 (void *)&cmd_set_port_tm_node_parent_node,
1993                 (void *)&cmd_set_port_tm_node_parent_parent,
1994                 (void *)&cmd_set_port_tm_node_parent_port_id,
1995                 (void *)&cmd_set_port_tm_node_parent_node_id,
1996                 (void *)&cmd_set_port_tm_node_parent_parent_id,
1997                 (void *)&cmd_set_port_tm_node_parent_priority,
1998                 (void *)&cmd_set_port_tm_node_parent_weight,
1999                 NULL,
2000         },
2001 };
2002
2003 /* *** Suspend Port TM Node *** */
2004 struct cmd_suspend_port_tm_node_result {
2005         cmdline_fixed_string_t suspend;
2006         cmdline_fixed_string_t port;
2007         cmdline_fixed_string_t tm;
2008         cmdline_fixed_string_t node;
2009         uint16_t port_id;
2010         uint32_t node_id;
2011 };
2012
2013 cmdline_parse_token_string_t cmd_suspend_port_tm_node_suspend =
2014         TOKEN_STRING_INITIALIZER(
2015                 struct cmd_suspend_port_tm_node_result, suspend, "suspend");
2016 cmdline_parse_token_string_t cmd_suspend_port_tm_node_port =
2017         TOKEN_STRING_INITIALIZER(
2018                 struct cmd_suspend_port_tm_node_result, port, "port");
2019 cmdline_parse_token_string_t cmd_suspend_port_tm_node_tm =
2020         TOKEN_STRING_INITIALIZER(
2021                 struct cmd_suspend_port_tm_node_result, tm, "tm");
2022 cmdline_parse_token_string_t cmd_suspend_port_tm_node_node =
2023         TOKEN_STRING_INITIALIZER(
2024                 struct cmd_suspend_port_tm_node_result, node, "node");
2025 cmdline_parse_token_num_t cmd_suspend_port_tm_node_port_id =
2026         TOKEN_NUM_INITIALIZER(
2027                 struct cmd_suspend_port_tm_node_result, port_id, UINT16);
2028 cmdline_parse_token_num_t cmd_suspend_port_tm_node_node_id =
2029         TOKEN_NUM_INITIALIZER(
2030                 struct cmd_suspend_port_tm_node_result, node_id, UINT32);
2031
2032 static void cmd_suspend_port_tm_node_parsed(void *parsed_result,
2033         __attribute__((unused)) struct cmdline *cl,
2034         __attribute__((unused)) void *data)
2035 {
2036         struct cmd_suspend_port_tm_node_result *res = parsed_result;
2037         struct rte_tm_error error;
2038         uint32_t node_id = res->node_id;
2039         portid_t port_id = res->port_id;
2040         int ret;
2041
2042         if (port_id_is_invalid(port_id, ENABLED_WARN))
2043                 return;
2044
2045         memset(&error, 0, sizeof(struct rte_tm_error));
2046         ret = rte_tm_node_suspend(port_id, node_id, &error);
2047         if (ret != 0) {
2048                 print_err_msg(&error);
2049                 return;
2050         }
2051 }
2052
2053 cmdline_parse_inst_t cmd_suspend_port_tm_node = {
2054         .f = cmd_suspend_port_tm_node_parsed,
2055         .data = NULL,
2056         .help_str = "Suspend port tm node",
2057         .tokens = {
2058                 (void *)&cmd_suspend_port_tm_node_suspend,
2059                 (void *)&cmd_suspend_port_tm_node_port,
2060                 (void *)&cmd_suspend_port_tm_node_tm,
2061                 (void *)&cmd_suspend_port_tm_node_node,
2062                 (void *)&cmd_suspend_port_tm_node_port_id,
2063                 (void *)&cmd_suspend_port_tm_node_node_id,
2064                 NULL,
2065         },
2066 };
2067
2068 /* *** Resume Port TM Node *** */
2069 struct cmd_resume_port_tm_node_result {
2070         cmdline_fixed_string_t resume;
2071         cmdline_fixed_string_t port;
2072         cmdline_fixed_string_t tm;
2073         cmdline_fixed_string_t node;
2074         uint16_t port_id;
2075         uint32_t node_id;
2076 };
2077
2078 cmdline_parse_token_string_t cmd_resume_port_tm_node_resume =
2079         TOKEN_STRING_INITIALIZER(
2080                 struct cmd_resume_port_tm_node_result, resume, "resume");
2081 cmdline_parse_token_string_t cmd_resume_port_tm_node_port =
2082         TOKEN_STRING_INITIALIZER(
2083                 struct cmd_resume_port_tm_node_result, port, "port");
2084 cmdline_parse_token_string_t cmd_resume_port_tm_node_tm =
2085         TOKEN_STRING_INITIALIZER(
2086                 struct cmd_resume_port_tm_node_result, tm, "tm");
2087 cmdline_parse_token_string_t cmd_resume_port_tm_node_node =
2088         TOKEN_STRING_INITIALIZER(
2089                 struct cmd_resume_port_tm_node_result, node, "node");
2090 cmdline_parse_token_num_t cmd_resume_port_tm_node_port_id =
2091         TOKEN_NUM_INITIALIZER(
2092                 struct cmd_resume_port_tm_node_result, port_id, UINT16);
2093 cmdline_parse_token_num_t cmd_resume_port_tm_node_node_id =
2094         TOKEN_NUM_INITIALIZER(
2095                 struct cmd_resume_port_tm_node_result, node_id, UINT32);
2096
2097 static void cmd_resume_port_tm_node_parsed(void *parsed_result,
2098         __attribute__((unused)) struct cmdline *cl,
2099         __attribute__((unused)) void *data)
2100 {
2101         struct cmd_resume_port_tm_node_result *res = parsed_result;
2102         struct rte_tm_error error;
2103         uint32_t node_id = res->node_id;
2104         portid_t port_id = res->port_id;
2105         int ret;
2106
2107         if (port_id_is_invalid(port_id, ENABLED_WARN))
2108                 return;
2109
2110         memset(&error, 0, sizeof(struct rte_tm_error));
2111         ret = rte_tm_node_resume(port_id, node_id, &error);
2112         if (ret != 0) {
2113                 print_err_msg(&error);
2114                 return;
2115         }
2116 }
2117
2118 cmdline_parse_inst_t cmd_resume_port_tm_node = {
2119         .f = cmd_resume_port_tm_node_parsed,
2120         .data = NULL,
2121         .help_str = "Resume port tm node",
2122         .tokens = {
2123                 (void *)&cmd_resume_port_tm_node_resume,
2124                 (void *)&cmd_resume_port_tm_node_port,
2125                 (void *)&cmd_resume_port_tm_node_tm,
2126                 (void *)&cmd_resume_port_tm_node_node,
2127                 (void *)&cmd_resume_port_tm_node_port_id,
2128                 (void *)&cmd_resume_port_tm_node_node_id,
2129                 NULL,
2130         },
2131 };
2132
2133 /* *** Port TM Hierarchy Commit *** */
2134 struct cmd_port_tm_hierarchy_commit_result {
2135         cmdline_fixed_string_t port;
2136         cmdline_fixed_string_t tm;
2137         cmdline_fixed_string_t hierarchy;
2138         cmdline_fixed_string_t commit;
2139         uint16_t port_id;
2140         cmdline_fixed_string_t clean_on_fail;
2141 };
2142
2143 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_port =
2144         TOKEN_STRING_INITIALIZER(
2145                 struct cmd_port_tm_hierarchy_commit_result, port, "port");
2146 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_tm =
2147         TOKEN_STRING_INITIALIZER(
2148                 struct cmd_port_tm_hierarchy_commit_result, tm, "tm");
2149 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_hierarchy =
2150         TOKEN_STRING_INITIALIZER(
2151                 struct cmd_port_tm_hierarchy_commit_result,
2152                         hierarchy, "hierarchy");
2153 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_commit =
2154         TOKEN_STRING_INITIALIZER(
2155                 struct cmd_port_tm_hierarchy_commit_result, commit, "commit");
2156 cmdline_parse_token_num_t cmd_port_tm_hierarchy_commit_port_id =
2157         TOKEN_NUM_INITIALIZER(
2158                 struct cmd_port_tm_hierarchy_commit_result,
2159                         port_id, UINT16);
2160 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_clean_on_fail =
2161         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_hierarchy_commit_result,
2162                  clean_on_fail, "yes#no");
2163
2164 static void cmd_port_tm_hierarchy_commit_parsed(void *parsed_result,
2165         __attribute__((unused)) struct cmdline *cl,
2166         __attribute__((unused)) void *data)
2167 {
2168         struct cmd_port_tm_hierarchy_commit_result *res = parsed_result;
2169         struct rte_tm_error error;
2170         uint32_t clean_on_fail;
2171         portid_t port_id = res->port_id;
2172         int ret;
2173
2174         if (port_id_is_invalid(port_id, ENABLED_WARN))
2175                 return;
2176
2177         if (strcmp(res->clean_on_fail, "yes") == 0)
2178                 clean_on_fail = 1;
2179         else
2180                 clean_on_fail = 0;
2181
2182         memset(&error, 0, sizeof(struct rte_tm_error));
2183         ret = rte_tm_hierarchy_commit(port_id, clean_on_fail, &error);
2184         if (ret != 0) {
2185                 print_err_msg(&error);
2186                 return;
2187         }
2188 }
2189
2190 cmdline_parse_inst_t cmd_port_tm_hierarchy_commit = {
2191         .f = cmd_port_tm_hierarchy_commit_parsed,
2192         .data = NULL,
2193         .help_str = "Commit port tm hierarchy",
2194         .tokens = {
2195                 (void *)&cmd_port_tm_hierarchy_commit_port,
2196                 (void *)&cmd_port_tm_hierarchy_commit_tm,
2197                 (void *)&cmd_port_tm_hierarchy_commit_hierarchy,
2198                 (void *)&cmd_port_tm_hierarchy_commit_commit,
2199                 (void *)&cmd_port_tm_hierarchy_commit_port_id,
2200                 (void *)&cmd_port_tm_hierarchy_commit_clean_on_fail,
2201                 NULL,
2202         },
2203 };
2204
2205 /* *** Port TM Mark IP ECN *** */
2206 struct cmd_port_tm_mark_ip_ecn_result {
2207         cmdline_fixed_string_t set;
2208         cmdline_fixed_string_t port;
2209         cmdline_fixed_string_t tm;
2210         cmdline_fixed_string_t mark;
2211         cmdline_fixed_string_t ip_ecn;
2212         uint16_t port_id;
2213         uint16_t green;
2214         uint16_t yellow;
2215         uint16_t red;
2216 };
2217
2218 cmdline_parse_token_string_t cmd_port_tm_mark_ip_ecn_set =
2219         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2220                                  set, "set");
2221
2222 cmdline_parse_token_string_t cmd_port_tm_mark_ip_ecn_port =
2223         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2224                                  port, "port");
2225
2226 cmdline_parse_token_string_t cmd_port_tm_mark_ip_ecn_tm =
2227         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result, tm,
2228                                  "tm");
2229
2230 cmdline_parse_token_string_t cmd_port_tm_mark_ip_ecn_mark =
2231         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2232                                  mark, "mark");
2233
2234 cmdline_parse_token_string_t cmd_port_tm_mark_ip_ecn_ip_ecn =
2235         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2236                                  ip_ecn, "ip_ecn");
2237 cmdline_parse_token_num_t cmd_port_tm_mark_ip_ecn_port_id =
2238         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2239                               port_id, UINT16);
2240
2241 cmdline_parse_token_num_t cmd_port_tm_mark_ip_ecn_green =
2242         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2243                               green, UINT16);
2244 cmdline_parse_token_num_t cmd_port_tm_mark_ip_ecn_yellow =
2245         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2246                               yellow, UINT16);
2247 cmdline_parse_token_num_t cmd_port_tm_mark_ip_ecn_red =
2248         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_ecn_result,
2249                                 red, UINT16);
2250
2251 static void cmd_port_tm_mark_ip_ecn_parsed(void *parsed_result,
2252         __attribute__((unused)) struct cmdline *cl,
2253         __attribute__((unused)) void *data)
2254 {
2255         struct cmd_port_tm_mark_ip_ecn_result *res = parsed_result;
2256         struct rte_tm_error error;
2257         portid_t port_id = res->port_id;
2258         int green = res->green;
2259         int yellow = res->yellow;
2260         int red = res->red;
2261         int ret;
2262         if (port_id_is_invalid(port_id, ENABLED_WARN))
2263                 return;
2264
2265         memset(&error, 0, sizeof(struct rte_tm_error));
2266         ret = rte_tm_mark_ip_ecn(port_id, green, yellow, red, &error);
2267         if (ret != 0) {
2268                 print_err_msg(&error);
2269                 return;
2270         }
2271 }
2272
2273 cmdline_parse_inst_t cmd_port_tm_mark_ip_ecn = {
2274         .f = cmd_port_tm_mark_ip_ecn_parsed,
2275         .data = NULL,
2276         .help_str = "set port tm mark ip_ecn <port> <green> <yellow> <red>",
2277         .tokens = {
2278                 (void *)&cmd_port_tm_mark_ip_ecn_set,
2279                 (void *)&cmd_port_tm_mark_ip_ecn_port,
2280                 (void *)&cmd_port_tm_mark_ip_ecn_tm,
2281                 (void *)&cmd_port_tm_mark_ip_ecn_mark,
2282                 (void *)&cmd_port_tm_mark_ip_ecn_ip_ecn,
2283                 (void *)&cmd_port_tm_mark_ip_ecn_port_id,
2284                 (void *)&cmd_port_tm_mark_ip_ecn_green,
2285                 (void *)&cmd_port_tm_mark_ip_ecn_yellow,
2286                 (void *)&cmd_port_tm_mark_ip_ecn_red,
2287                 NULL,
2288         },
2289 };
2290
2291
2292 /* *** Port TM Mark IP DSCP *** */
2293 struct cmd_port_tm_mark_ip_dscp_result {
2294         cmdline_fixed_string_t set;
2295         cmdline_fixed_string_t port;
2296         cmdline_fixed_string_t tm;
2297         cmdline_fixed_string_t mark;
2298         cmdline_fixed_string_t ip_dscp;
2299         uint16_t port_id;
2300         uint16_t green;
2301         uint16_t yellow;
2302         uint16_t red;
2303 };
2304
2305 cmdline_parse_token_string_t cmd_port_tm_mark_ip_dscp_set =
2306         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2307                                  set, "set");
2308
2309 cmdline_parse_token_string_t cmd_port_tm_mark_ip_dscp_port =
2310         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2311                                  port, "port");
2312
2313 cmdline_parse_token_string_t cmd_port_tm_mark_ip_dscp_tm =
2314         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result, tm,
2315                                  "tm");
2316
2317 cmdline_parse_token_string_t cmd_port_tm_mark_ip_dscp_mark =
2318         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2319                                  mark, "mark");
2320
2321 cmdline_parse_token_string_t cmd_port_tm_mark_ip_dscp_ip_dscp =
2322         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2323                                  ip_dscp, "ip_dscp");
2324 cmdline_parse_token_num_t cmd_port_tm_mark_ip_dscp_port_id =
2325         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2326                               port_id, UINT16);
2327
2328 cmdline_parse_token_num_t cmd_port_tm_mark_ip_dscp_green =
2329         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2330                                 green, UINT16);
2331 cmdline_parse_token_num_t cmd_port_tm_mark_ip_dscp_yellow =
2332         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2333                                 yellow, UINT16);
2334 cmdline_parse_token_num_t cmd_port_tm_mark_ip_dscp_red =
2335         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_ip_dscp_result,
2336                                 red, UINT16);
2337
2338 static void cmd_port_tm_mark_ip_dscp_parsed(void *parsed_result,
2339         __attribute__((unused)) struct cmdline *cl,
2340         __attribute__((unused)) void *data)
2341 {
2342         struct cmd_port_tm_mark_ip_dscp_result *res = parsed_result;
2343         struct rte_tm_error error;
2344         portid_t port_id = res->port_id;
2345         int green = res->green;
2346         int yellow = res->yellow;
2347         int red = res->red;
2348         int ret;
2349         if (port_id_is_invalid(port_id, ENABLED_WARN))
2350                 return;
2351
2352         memset(&error, 0, sizeof(struct rte_tm_error));
2353         ret = rte_tm_mark_ip_dscp(port_id, green, yellow, red, &error);
2354         if (ret != 0) {
2355                 print_err_msg(&error);
2356                 return;
2357         }
2358 }
2359
2360 cmdline_parse_inst_t cmd_port_tm_mark_ip_dscp = {
2361         .f = cmd_port_tm_mark_ip_dscp_parsed,
2362         .data = NULL,
2363         .help_str = "set port tm mark ip_dscp <port> <green> <yellow> <red>",
2364         .tokens = {
2365                 (void *)&cmd_port_tm_mark_ip_dscp_set,
2366                 (void *)&cmd_port_tm_mark_ip_dscp_port,
2367                 (void *)&cmd_port_tm_mark_ip_dscp_tm,
2368                 (void *)&cmd_port_tm_mark_ip_dscp_mark,
2369                 (void *)&cmd_port_tm_mark_ip_dscp_ip_dscp,
2370                 (void *)&cmd_port_tm_mark_ip_dscp_port_id,
2371                 (void *)&cmd_port_tm_mark_ip_dscp_green,
2372                 (void *)&cmd_port_tm_mark_ip_dscp_yellow,
2373                 (void *)&cmd_port_tm_mark_ip_dscp_red,
2374                 NULL,
2375         },
2376 };
2377
2378
2379 /* *** Port TM Mark VLAN_DEI *** */
2380 struct cmd_port_tm_mark_vlan_dei_result {
2381         cmdline_fixed_string_t set;
2382         cmdline_fixed_string_t port;
2383         cmdline_fixed_string_t tm;
2384         cmdline_fixed_string_t mark;
2385         cmdline_fixed_string_t vlan_dei;
2386         uint16_t port_id;
2387         uint16_t green;
2388         uint16_t yellow;
2389         uint16_t red;
2390 };
2391
2392 cmdline_parse_token_string_t cmd_port_tm_mark_vlan_dei_set =
2393         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2394                                  set, "set");
2395
2396 cmdline_parse_token_string_t cmd_port_tm_mark_vlan_dei_port =
2397         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2398                                  port, "port");
2399
2400 cmdline_parse_token_string_t cmd_port_tm_mark_vlan_dei_tm =
2401         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result, tm,
2402                                  "tm");
2403
2404 cmdline_parse_token_string_t cmd_port_tm_mark_vlan_dei_mark =
2405         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2406                                  mark, "mark");
2407
2408 cmdline_parse_token_string_t cmd_port_tm_mark_vlan_dei_vlan_dei =
2409         TOKEN_STRING_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2410                                  vlan_dei, "vlan_dei");
2411 cmdline_parse_token_num_t cmd_port_tm_mark_vlan_dei_port_id =
2412         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2413                               port_id, UINT16);
2414
2415 cmdline_parse_token_num_t cmd_port_tm_mark_vlan_dei_green =
2416         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2417                                 green, UINT16);
2418 cmdline_parse_token_num_t cmd_port_tm_mark_vlan_dei_yellow =
2419         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2420                                 yellow, UINT16);
2421 cmdline_parse_token_num_t cmd_port_tm_mark_vlan_dei_red =
2422         TOKEN_NUM_INITIALIZER(struct cmd_port_tm_mark_vlan_dei_result,
2423                                 red, UINT16);
2424
2425 static void cmd_port_tm_mark_vlan_dei_parsed(void *parsed_result,
2426         __attribute__((unused)) struct cmdline *cl,
2427         __attribute__((unused)) void *data)
2428 {
2429         struct cmd_port_tm_mark_vlan_dei_result *res = parsed_result;
2430         struct rte_tm_error error;
2431         portid_t port_id = res->port_id;
2432         int green = res->green;
2433         int yellow = res->yellow;
2434         int red = res->red;
2435         int ret;
2436         if (port_id_is_invalid(port_id, ENABLED_WARN))
2437                 return;
2438
2439         memset(&error, 0, sizeof(struct rte_tm_error));
2440         ret = rte_tm_mark_vlan_dei(port_id, green, yellow, red, &error);
2441         if (ret != 0) {
2442                 print_err_msg(&error);
2443                 return;
2444         }
2445 }
2446
2447 cmdline_parse_inst_t cmd_port_tm_mark_vlan_dei = {
2448         .f = cmd_port_tm_mark_vlan_dei_parsed,
2449         .data = NULL,
2450         .help_str = "set port tm mark vlan_dei <port> <green> <yellow> <red>",
2451         .tokens = {
2452                 (void *)&cmd_port_tm_mark_vlan_dei_set,
2453                 (void *)&cmd_port_tm_mark_vlan_dei_port,
2454                 (void *)&cmd_port_tm_mark_vlan_dei_tm,
2455                 (void *)&cmd_port_tm_mark_vlan_dei_mark,
2456                 (void *)&cmd_port_tm_mark_vlan_dei_vlan_dei,
2457                 (void *)&cmd_port_tm_mark_vlan_dei_port_id,
2458                 (void *)&cmd_port_tm_mark_vlan_dei_green,
2459                 (void *)&cmd_port_tm_mark_vlan_dei_yellow,
2460                 (void *)&cmd_port_tm_mark_vlan_dei_red,
2461                 NULL,
2462         },
2463 };