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