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