1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
3 */
4
5 #include <cmdline_parse.h>
6 #include <cmdline_parse_num.h>
7 #include <cmdline_parse_string.h>
8
9 #include <rte_ethdev.h>
10 #include <rte_flow.h>
11 #include <rte_tm.h>
12
13 #include "testpmd.h"
14 #include "cmdline_tm.h"
15
16 #define PARSE_DELIMITER " \f\n\r\t\v"
17 #define MAX_NUM_SHARED_SHAPERS 256
18
19 #define skip_white_spaces(pos) \
20 ({ \
21 __typeof__(pos) _p = (pos); \
22 for ( ; isspace(*_p); _p++) \
23 ; \
24 _p; \
25 })
26
27 /** Display TM Error Message */
28 static void
print_err_msg(struct rte_tm_error * error)29 print_err_msg(struct rte_tm_error *error)
30 {
31 static const char *const errstrlist[] = {
32 [RTE_TM_ERROR_TYPE_NONE] = "no error",
33 [RTE_TM_ERROR_TYPE_UNSPECIFIED] = "cause unspecified",
34 [RTE_TM_ERROR_TYPE_CAPABILITIES]
35 = "capability parameter null",
36 [RTE_TM_ERROR_TYPE_LEVEL_ID] = "level id",
37 [RTE_TM_ERROR_TYPE_WRED_PROFILE]
38 = "wred profile null",
39 [RTE_TM_ERROR_TYPE_WRED_PROFILE_GREEN] = "wred profile(green)",
40 [RTE_TM_ERROR_TYPE_WRED_PROFILE_YELLOW]
41 = "wred profile(yellow)",
42 [RTE_TM_ERROR_TYPE_WRED_PROFILE_RED] = "wred profile(red)",
43 [RTE_TM_ERROR_TYPE_WRED_PROFILE_ID] = "wred profile id",
44 [RTE_TM_ERROR_TYPE_SHARED_WRED_CONTEXT_ID]
45 = "shared wred context id",
46 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE] = "shaper profile null",
47 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_RATE]
48 = "committed rate field (shaper profile)",
49 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_COMMITTED_SIZE]
50 = "committed size field (shaper profile)",
51 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_RATE]
52 = "peak rate field (shaper profile)",
53 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PEAK_SIZE]
54 = "peak size field (shaper profile)",
55 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PKT_ADJUST_LEN]
56 = "packet adjust length field (shaper profile)",
57 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_PACKET_MODE]
58 = "packet mode field (shaper profile)",
59 [RTE_TM_ERROR_TYPE_SHAPER_PROFILE_ID] = "shaper profile id",
60 [RTE_TM_ERROR_TYPE_SHARED_SHAPER_ID] = "shared shaper id",
61 [RTE_TM_ERROR_TYPE_NODE_PARENT_NODE_ID] = "parent node id",
62 [RTE_TM_ERROR_TYPE_NODE_PRIORITY] = "node priority",
63 [RTE_TM_ERROR_TYPE_NODE_WEIGHT] = "node weight",
64 [RTE_TM_ERROR_TYPE_NODE_PARAMS] = "node parameter null",
65 [RTE_TM_ERROR_TYPE_NODE_PARAMS_SHAPER_PROFILE_ID]
66 = "shaper profile id field (node params)",
67 [RTE_TM_ERROR_TYPE_NODE_PARAMS_SHARED_SHAPER_ID]
68 = "shared shaper id field (node params)",
69 [RTE_TM_ERROR_TYPE_NODE_PARAMS_N_SHARED_SHAPERS]
70 = "num shared shapers field (node params)",
71 [RTE_TM_ERROR_TYPE_NODE_PARAMS_WFQ_WEIGHT_MODE]
72 = "wfq weight 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
106 static int
read_uint64(uint64_t * value,const char * p)107 read_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 /* fall through */
125 case 'G':
126 val *= 1024ULL;
127 /* fall through */
128 case 'M':
129 val *= 1024ULL;
130 /* fall through */
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
146 static int
read_uint32(uint32_t * value,const char * p)147 read_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
162 static int
parse_multi_ss_id_str(char * s_str,uint32_t * n_ssp,uint32_t shaper_id[])163 parse_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 /* First token: num of shared shapers */
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 /* Check: num of shared shaper */
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 /* Parse shared shaper ids */
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 /* *** Port TM Capability *** */
202 struct 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
210 cmdline_parse_token_string_t cmd_show_port_tm_cap_show =
211 TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
212 show, "show");
213 cmdline_parse_token_string_t cmd_show_port_tm_cap_port =
214 TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
215 port, "port");
216 cmdline_parse_token_string_t cmd_show_port_tm_cap_tm =
217 TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
218 tm, "tm");
219 cmdline_parse_token_string_t cmd_show_port_tm_cap_cap =
220 TOKEN_STRING_INITIALIZER(struct cmd_show_port_tm_cap_result,
221 cap, "cap");
222 cmdline_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
cmd_show_port_tm_cap_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)226 static 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
331 cmdline_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 /* *** Port TM Hierarchical Level Capability *** */
346 struct 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
356 cmdline_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");
359 cmdline_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");
362 cmdline_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");
365 cmdline_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");
368 cmdline_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");
371 cmdline_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);
374 cmdline_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
cmd_show_port_tm_level_cap_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)379 static 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
479 cmdline_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 hierarchical 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 /* *** Port TM Hierarchy Node Capability *** */
496 struct 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
506 cmdline_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");
509 cmdline_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");
512 cmdline_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");
515 cmdline_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");
518 cmdline_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");
521 cmdline_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);
524 cmdline_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
cmd_show_port_tm_node_cap_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)528 static 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 /* Node id must be valid */
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
602 cmdline_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 /* *** Show Port TM Node Statistics *** */
619 struct 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
630 cmdline_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");
633 cmdline_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");
636 cmdline_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");
639 cmdline_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");
642 cmdline_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");
645 cmdline_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);
648 cmdline_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);
652 cmdline_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
cmd_show_port_tm_node_stats_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)656 static 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 /* Port status */
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 /* Display stats */
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
720 cmdline_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 /* *** Show Port TM Node Type *** */
738 struct 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
748 cmdline_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");
751 cmdline_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");
754 cmdline_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");
757 cmdline_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");
760 cmdline_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");
763 cmdline_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);
767 cmdline_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
cmd_show_port_tm_node_type_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)772 static 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
799 cmdline_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 /* *** Add Port TM Private Shaper Profile *** */
816 struct 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
833 cmdline_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");
836 cmdline_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");
840 cmdline_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");
844 cmdline_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");
848 cmdline_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");
852 cmdline_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");
856 cmdline_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);
860 cmdline_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);
864 cmdline_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);
868 cmdline_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);
872 cmdline_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);
876 cmdline_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);
880 cmdline_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);
884 cmdline_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
cmd_add_port_tm_node_shaper_profile_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)889 static 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 /* Private shaper profile params */
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
921 cmdline_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 /* *** Delete Port TM Private Shaper Profile *** */
945 struct 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
956 cmdline_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");
959 cmdline_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");
963 cmdline_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");
966 cmdline_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");
970 cmdline_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");
974 cmdline_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");
978 cmdline_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);
982 cmdline_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
cmd_del_port_tm_node_shaper_profile_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)987 static 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
1008 cmdline_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 /* *** Add/Update Port TM shared Shaper *** */
1026 struct 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
1038 cmdline_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");
1042 cmdline_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");
1045 cmdline_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");
1048 cmdline_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");
1051 cmdline_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");
1055 cmdline_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");
1059 cmdline_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);
1063 cmdline_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);
1067 cmdline_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
cmd_add_port_tm_node_shared_shaper_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1072 static 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 /* Command type: add */
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 /* Command type: set (update) */
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
1109 cmdline_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 /* *** Delete Port TM shared Shaper *** */
1128 struct 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
1139 cmdline_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");
1142 cmdline_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");
1145 cmdline_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");
1148 cmdline_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");
1151 cmdline_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");
1155 cmdline_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");
1159 cmdline_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);
1163 cmdline_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
cmd_del_port_tm_node_shared_shaper_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1168 static 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
1189 cmdline_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 /* *** Add Port TM Node WRED Profile *** */
1207 struct 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
1233 cmdline_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");
1236 cmdline_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");
1239 cmdline_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");
1242 cmdline_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");
1245 cmdline_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");
1248 cmdline_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");
1252 cmdline_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);
1256 cmdline_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);
1260 cmdline_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");
1264 cmdline_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);
1268 cmdline_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);
1272 cmdline_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);
1276 cmdline_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);
1280 cmdline_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");
1284 cmdline_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);
1288 cmdline_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);
1292 cmdline_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);
1296 cmdline_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);
1300 cmdline_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");
1304 cmdline_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);
1308 cmdline_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);
1312 cmdline_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);
1316 cmdline_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
cmd_add_port_tm_node_wred_profile_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1322 static 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 /* WRED Params (Green Color)*/
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 /* WRED Params (Yellow Color)*/
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 /* WRED Params (Red Color)*/
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
1369 cmdline_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 /* *** Delete Port TM node WRED Profile *** */
1402 struct 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
1413 cmdline_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");
1416 cmdline_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");
1419 cmdline_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");
1422 cmdline_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");
1425 cmdline_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");
1428 cmdline_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");
1432 cmdline_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);
1436 cmdline_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
cmd_del_port_tm_node_wred_profile_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1441 static 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
1462 cmdline_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 /* *** Update Port TM Node Shaper profile *** */
1480 struct 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
1492 cmdline_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");
1495 cmdline_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");
1499 cmdline_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");
1502 cmdline_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");
1506 cmdline_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");
1510 cmdline_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");
1514 cmdline_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);
1518 cmdline_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);
1521 cmdline_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
cmd_set_port_tm_node_shaper_profile_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1527 static 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 /* Port status */
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
1556 cmdline_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 /* *** Add Port TM nonleaf node *** */
1575 struct 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
1593 cmdline_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");
1596 cmdline_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");
1599 cmdline_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");
1602 cmdline_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");
1605 cmdline_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");
1608 cmdline_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);
1612 cmdline_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);
1615 cmdline_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);
1618 cmdline_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);
1621 cmdline_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);
1624 cmdline_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);
1627 cmdline_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);
1630 cmdline_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);
1633 cmdline_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);
1636 cmdline_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
cmd_add_port_tm_nonleaf_node_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1641 static 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 /* Node parameters */
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 /* Parse multi shared shaper id string */
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
1709 cmdline_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 /* *** Add Port TM nonleaf node pkt mode *** */
1734 struct 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
1752 cmdline_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");
1755 cmdline_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");
1758 cmdline_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");
1761 cmdline_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");
1764 cmdline_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");
1767 cmdline_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");
1770 cmdline_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);
1774 cmdline_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);
1777 cmdline_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);
1780 cmdline_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);
1783 cmdline_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);
1786 cmdline_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);
1789 cmdline_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);
1792 cmdline_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);
1795 cmdline_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);
1798 cmdline_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
cmd_add_port_tm_nonleaf_node_pmode_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1804 static 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 /* Node parameters */
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 /* Parse multi shared shaper id string */
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
1876 cmdline_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 /* *** Add Port TM leaf node *** */
1901 struct 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
1920 cmdline_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");
1923 cmdline_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");
1926 cmdline_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");
1929 cmdline_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");
1932 cmdline_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");
1935 cmdline_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);
1938 cmdline_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);
1941 cmdline_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);
1944 cmdline_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);
1947 cmdline_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);
1950 cmdline_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);
1953 cmdline_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);
1956 cmdline_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);
1959 cmdline_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);
1962 cmdline_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);
1965 cmdline_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
cmd_add_port_tm_leaf_node_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)1970 static 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 /* Node parameters */
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 /* Parse multi shared shaper id string */
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
2039 cmdline_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 /* *** Delete Port TM Node *** */
2065 struct 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
2074 cmdline_parse_token_string_t cmd_del_port_tm_node_del =
2075 TOKEN_STRING_INITIALIZER(
2076 struct cmd_del_port_tm_node_result, del, "del");
2077 cmdline_parse_token_string_t cmd_del_port_tm_node_port =
2078 TOKEN_STRING_INITIALIZER(
2079 struct cmd_del_port_tm_node_result, port, "port");
2080 cmdline_parse_token_string_t cmd_del_port_tm_node_tm =
2081 TOKEN_STRING_INITIALIZER(
2082 struct cmd_del_port_tm_node_result, tm, "tm");
2083 cmdline_parse_token_string_t cmd_del_port_tm_node_node =
2084 TOKEN_STRING_INITIALIZER(
2085 struct cmd_del_port_tm_node_result, node, "node");
2086 cmdline_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);
2089 cmdline_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
cmd_del_port_tm_node_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2093 static 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 /* Port status */
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
2120 cmdline_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 /* *** Update Port TM Node Parent *** */
2136 struct 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
2149 cmdline_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");
2152 cmdline_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");
2155 cmdline_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");
2158 cmdline_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");
2161 cmdline_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");
2164 cmdline_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);
2168 cmdline_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);
2172 cmdline_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);
2175 cmdline_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);
2178 cmdline_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
cmd_set_port_tm_node_parent_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2182 static 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 /* Port status */
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
2213 cmdline_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 /* *** Suspend Port TM Node *** */
2233 struct 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
2242 cmdline_parse_token_string_t cmd_suspend_port_tm_node_suspend =
2243 TOKEN_STRING_INITIALIZER(
2244 struct cmd_suspend_port_tm_node_result, suspend, "suspend");
2245 cmdline_parse_token_string_t cmd_suspend_port_tm_node_port =
2246 TOKEN_STRING_INITIALIZER(
2247 struct cmd_suspend_port_tm_node_result, port, "port");
2248 cmdline_parse_token_string_t cmd_suspend_port_tm_node_tm =
2249 TOKEN_STRING_INITIALIZER(
2250 struct cmd_suspend_port_tm_node_result, tm, "tm");
2251 cmdline_parse_token_string_t cmd_suspend_port_tm_node_node =
2252 TOKEN_STRING_INITIALIZER(
2253 struct cmd_suspend_port_tm_node_result, node, "node");
2254 cmdline_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);
2258 cmdline_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
cmd_suspend_port_tm_node_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2263 static 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
2284 cmdline_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 /* *** Resume Port TM Node *** */
2300 struct 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
2309 cmdline_parse_token_string_t cmd_resume_port_tm_node_resume =
2310 TOKEN_STRING_INITIALIZER(
2311 struct cmd_resume_port_tm_node_result, resume, "resume");
2312 cmdline_parse_token_string_t cmd_resume_port_tm_node_port =
2313 TOKEN_STRING_INITIALIZER(
2314 struct cmd_resume_port_tm_node_result, port, "port");
2315 cmdline_parse_token_string_t cmd_resume_port_tm_node_tm =
2316 TOKEN_STRING_INITIALIZER(
2317 struct cmd_resume_port_tm_node_result, tm, "tm");
2318 cmdline_parse_token_string_t cmd_resume_port_tm_node_node =
2319 TOKEN_STRING_INITIALIZER(
2320 struct cmd_resume_port_tm_node_result, node, "node");
2321 cmdline_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);
2324 cmdline_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
cmd_resume_port_tm_node_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2328 static 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
2349 cmdline_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 /* *** Port TM Hierarchy Commit *** */
2365 struct 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
2374 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_port =
2375 TOKEN_STRING_INITIALIZER(
2376 struct cmd_port_tm_hierarchy_commit_result, port, "port");
2377 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_tm =
2378 TOKEN_STRING_INITIALIZER(
2379 struct cmd_port_tm_hierarchy_commit_result, tm, "tm");
2380 cmdline_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");
2384 cmdline_parse_token_string_t cmd_port_tm_hierarchy_commit_commit =
2385 TOKEN_STRING_INITIALIZER(
2386 struct cmd_port_tm_hierarchy_commit_result, commit, "commit");
2387 cmdline_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);
2391 cmdline_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
cmd_port_tm_hierarchy_commit_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2395 static 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
2421 cmdline_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 /* *** Port TM Mark IP ECN *** */
2437 struct 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
2449 cmdline_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
2453 cmdline_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
2457 cmdline_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
2461 cmdline_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
2465 cmdline_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");
2468 cmdline_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
2472 cmdline_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);
2475 cmdline_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);
2478 cmdline_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
cmd_port_tm_mark_ip_ecn_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2482 static 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
2504 cmdline_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 /* *** Port TM Mark IP DSCP *** */
2524 struct 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
2536 cmdline_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
2540 cmdline_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
2544 cmdline_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
2548 cmdline_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
2552 cmdline_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");
2555 cmdline_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
2559 cmdline_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);
2562 cmdline_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);
2565 cmdline_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
cmd_port_tm_mark_ip_dscp_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2569 static 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
2591 cmdline_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 /* *** Port TM Mark VLAN_DEI *** */
2611 struct 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
2623 cmdline_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
2627 cmdline_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
2631 cmdline_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
2635 cmdline_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
2639 cmdline_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");
2642 cmdline_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
2646 cmdline_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);
2649 cmdline_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);
2652 cmdline_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
cmd_port_tm_mark_vlan_dei_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)2656 static 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
2678 cmdline_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