1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
3 */
4
5 #include <stdio.h>
6 #include <termios.h>
7 #include <inttypes.h>
8 #include <string.h>
9
10 #include <cmdline_rdline.h>
11 #include <cmdline_parse.h>
12 #include <cmdline_parse_num.h>
13 #include <cmdline_parse_string.h>
14 #include <cmdline_socket.h>
15 #include <cmdline.h>
16
17 #include "main.h"
18
19 /* *** Help command with introduction. *** */
20 struct cmd_help_result {
21 cmdline_fixed_string_t help;
22 };
23
cmd_help_parsed(__rte_unused void * parsed_result,struct cmdline * cl,__rte_unused void * data)24 static void cmd_help_parsed(__rte_unused void *parsed_result,
25 struct cmdline *cl,
26 __rte_unused void *data)
27 {
28 cmdline_printf(
29 cl,
30 "\n"
31 "The following commands are currently available:\n\n"
32 "Control:\n"
33 " quit : Quit the application.\n"
34 "\nStatistics:\n"
35 " stats app : Show app statistics.\n"
36 " stats port X subport Y : Show stats of a specific subport.\n"
37 " stats port X subport Y pipe Z : Show stats of a specific pipe.\n"
38 "\nAverage queue size:\n"
39 " qavg port X subport Y : Show average queue size per subport.\n"
40 " qavg port X subport Y tc Z : Show average queue size per subport and TC.\n"
41 " qavg port X subport Y pipe Z : Show average queue size per pipe.\n"
42 " qavg port X subport Y pipe Z tc A : Show average queue size per pipe and TC.\n"
43 " qavg port X subport Y pipe Z tc A q B : Show average queue size of a specific queue.\n"
44 " qavg [n|period] X : Set number of times and period (us).\n\n"
45 );
46
47 }
48
49 cmdline_parse_token_string_t cmd_help_help =
50 TOKEN_STRING_INITIALIZER(struct cmd_help_result, help, "help");
51
52 cmdline_parse_inst_t cmd_help = {
53 .f = cmd_help_parsed,
54 .data = NULL,
55 .help_str = "show help",
56 .tokens = {
57 (void *)&cmd_help_help,
58 NULL,
59 },
60 };
61
62 /* *** QUIT *** */
63 struct cmd_quit_result {
64 cmdline_fixed_string_t quit;
65 };
66
cmd_quit_parsed(__rte_unused void * parsed_result,struct cmdline * cl,__rte_unused void * data)67 static void cmd_quit_parsed(__rte_unused void *parsed_result,
68 struct cmdline *cl,
69 __rte_unused void *data)
70 {
71 cmdline_quit(cl);
72 }
73
74 cmdline_parse_token_string_t cmd_quit_quit =
75 TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, "quit");
76
77 cmdline_parse_inst_t cmd_quit = {
78 .f = cmd_quit_parsed,
79 .data = NULL,
80 .help_str = "exit application",
81 .tokens = {
82 (void *)&cmd_quit_quit,
83 NULL,
84 },
85 };
86
87 /* *** SET QAVG PARAMETERS *** */
88 struct cmd_setqavg_result {
89 cmdline_fixed_string_t qavg_string;
90 cmdline_fixed_string_t param_string;
91 uint32_t number;
92 };
93
cmd_setqavg_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)94 static void cmd_setqavg_parsed(void *parsed_result,
95 __rte_unused struct cmdline *cl,
96 __rte_unused void *data)
97 {
98 struct cmd_setqavg_result *res = parsed_result;
99
100 if (!strcmp(res->param_string, "period"))
101 qavg_period = res->number;
102 else if (!strcmp(res->param_string, "n"))
103 qavg_ntimes = res->number;
104 else
105 printf("\nUnknown parameter.\n\n");
106 }
107
108 cmdline_parse_token_string_t cmd_setqavg_qavg_string =
109 TOKEN_STRING_INITIALIZER(struct cmd_setqavg_result, qavg_string,
110 "qavg");
111 cmdline_parse_token_string_t cmd_setqavg_param_string =
112 TOKEN_STRING_INITIALIZER(struct cmd_setqavg_result, param_string,
113 "period#n");
114 cmdline_parse_token_num_t cmd_setqavg_number =
115 TOKEN_NUM_INITIALIZER(struct cmd_setqavg_result, number,
116 RTE_UINT32);
117
118 cmdline_parse_inst_t cmd_setqavg = {
119 .f = cmd_setqavg_parsed,
120 .data = NULL,
121 .help_str = "Show subport stats.",
122 .tokens = {
123 (void *)&cmd_setqavg_qavg_string,
124 (void *)&cmd_setqavg_param_string,
125 (void *)&cmd_setqavg_number,
126 NULL,
127 },
128 };
129
130 /* *** SHOW APP STATS *** */
131 struct cmd_appstats_result {
132 cmdline_fixed_string_t stats_string;
133 cmdline_fixed_string_t app_string;
134 };
135
cmd_appstats_parsed(__rte_unused void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)136 static void cmd_appstats_parsed(__rte_unused void *parsed_result,
137 __rte_unused struct cmdline *cl,
138 __rte_unused void *data)
139 {
140 app_stat();
141 }
142
143 cmdline_parse_token_string_t cmd_appstats_stats_string =
144 TOKEN_STRING_INITIALIZER(struct cmd_appstats_result, stats_string,
145 "stats");
146 cmdline_parse_token_string_t cmd_appstats_app_string =
147 TOKEN_STRING_INITIALIZER(struct cmd_appstats_result, app_string,
148 "app");
149
150 cmdline_parse_inst_t cmd_appstats = {
151 .f = cmd_appstats_parsed,
152 .data = NULL,
153 .help_str = "Show app stats.",
154 .tokens = {
155 (void *)&cmd_appstats_stats_string,
156 (void *)&cmd_appstats_app_string,
157 NULL,
158 },
159 };
160
161 /* *** SHOW SUBPORT STATS *** */
162 struct cmd_subportstats_result {
163 cmdline_fixed_string_t stats_string;
164 cmdline_fixed_string_t port_string;
165 uint16_t port_number;
166 cmdline_fixed_string_t subport_string;
167 uint32_t subport_number;
168 };
169
cmd_subportstats_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)170 static void cmd_subportstats_parsed(void *parsed_result,
171 __rte_unused struct cmdline *cl,
172 __rte_unused void *data)
173 {
174 struct cmd_subportstats_result *res = parsed_result;
175
176 if (subport_stat(res->port_number, res->subport_number) < 0)
177 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
178 }
179
180 cmdline_parse_token_string_t cmd_subportstats_stats_string =
181 TOKEN_STRING_INITIALIZER(struct cmd_subportstats_result, stats_string,
182 "stats");
183 cmdline_parse_token_string_t cmd_subportstats_port_string =
184 TOKEN_STRING_INITIALIZER(struct cmd_subportstats_result, port_string,
185 "port");
186 cmdline_parse_token_string_t cmd_subportstats_subport_string =
187 TOKEN_STRING_INITIALIZER(struct cmd_subportstats_result, subport_string,
188 "subport");
189 cmdline_parse_token_num_t cmd_subportstats_subport_number =
190 TOKEN_NUM_INITIALIZER(struct cmd_subportstats_result, subport_number,
191 RTE_UINT32);
192 cmdline_parse_token_num_t cmd_subportstats_port_number =
193 TOKEN_NUM_INITIALIZER(struct cmd_subportstats_result, port_number,
194 RTE_UINT16);
195
196 cmdline_parse_inst_t cmd_subportstats = {
197 .f = cmd_subportstats_parsed,
198 .data = NULL,
199 .help_str = "Show subport stats.",
200 .tokens = {
201 (void *)&cmd_subportstats_stats_string,
202 (void *)&cmd_subportstats_port_string,
203 (void *)&cmd_subportstats_port_number,
204 (void *)&cmd_subportstats_subport_string,
205 (void *)&cmd_subportstats_subport_number,
206 NULL,
207 },
208 };
209
210 /* *** SHOW PIPE STATS *** */
211 struct cmd_pipestats_result {
212 cmdline_fixed_string_t stats_string;
213 cmdline_fixed_string_t port_string;
214 uint16_t port_number;
215 cmdline_fixed_string_t subport_string;
216 uint32_t subport_number;
217 cmdline_fixed_string_t pipe_string;
218 uint32_t pipe_number;
219 };
220
cmd_pipestats_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)221 static void cmd_pipestats_parsed(void *parsed_result,
222 __rte_unused struct cmdline *cl,
223 __rte_unused void *data)
224 {
225 struct cmd_pipestats_result *res = parsed_result;
226
227 if (pipe_stat(res->port_number, res->subport_number, res->pipe_number) < 0)
228 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
229 }
230
231 cmdline_parse_token_string_t cmd_pipestats_stats_string =
232 TOKEN_STRING_INITIALIZER(struct cmd_pipestats_result, stats_string,
233 "stats");
234 cmdline_parse_token_string_t cmd_pipestats_port_string =
235 TOKEN_STRING_INITIALIZER(struct cmd_pipestats_result, port_string,
236 "port");
237 cmdline_parse_token_num_t cmd_pipestats_port_number =
238 TOKEN_NUM_INITIALIZER(struct cmd_pipestats_result, port_number,
239 RTE_UINT16);
240 cmdline_parse_token_string_t cmd_pipestats_subport_string =
241 TOKEN_STRING_INITIALIZER(struct cmd_pipestats_result, subport_string,
242 "subport");
243 cmdline_parse_token_num_t cmd_pipestats_subport_number =
244 TOKEN_NUM_INITIALIZER(struct cmd_pipestats_result, subport_number,
245 RTE_UINT32);
246 cmdline_parse_token_string_t cmd_pipestats_pipe_string =
247 TOKEN_STRING_INITIALIZER(struct cmd_pipestats_result, pipe_string,
248 "pipe");
249 cmdline_parse_token_num_t cmd_pipestats_pipe_number =
250 TOKEN_NUM_INITIALIZER(struct cmd_pipestats_result, pipe_number,
251 RTE_UINT32);
252
253 cmdline_parse_inst_t cmd_pipestats = {
254 .f = cmd_pipestats_parsed,
255 .data = NULL,
256 .help_str = "Show pipe stats.",
257 .tokens = {
258 (void *)&cmd_pipestats_stats_string,
259 (void *)&cmd_pipestats_port_string,
260 (void *)&cmd_pipestats_port_number,
261 (void *)&cmd_pipestats_subport_string,
262 (void *)&cmd_pipestats_subport_number,
263 (void *)&cmd_pipestats_pipe_string,
264 (void *)&cmd_pipestats_pipe_number,
265 NULL,
266 },
267 };
268
269 /* *** SHOW AVERAGE QUEUE SIZE (QUEUE) *** */
270 struct cmd_avg_q_result {
271 cmdline_fixed_string_t qavg_string;
272 cmdline_fixed_string_t port_string;
273 uint16_t port_number;
274 cmdline_fixed_string_t subport_string;
275 uint32_t subport_number;
276 cmdline_fixed_string_t pipe_string;
277 uint32_t pipe_number;
278 cmdline_fixed_string_t tc_string;
279 uint8_t tc_number;
280 cmdline_fixed_string_t q_string;
281 uint8_t q_number;
282 };
283
cmd_avg_q_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)284 static void cmd_avg_q_parsed(void *parsed_result,
285 __rte_unused struct cmdline *cl,
286 __rte_unused void *data)
287 {
288 struct cmd_avg_q_result *res = parsed_result;
289
290 if (qavg_q(res->port_number, res->subport_number, res->pipe_number, res->tc_number, res->q_number) < 0)
291 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
292 }
293
294 cmdline_parse_token_string_t cmd_avg_q_qavg_string =
295 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, qavg_string,
296 "qavg");
297 cmdline_parse_token_string_t cmd_avg_q_port_string =
298 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, port_string,
299 "port");
300 cmdline_parse_token_num_t cmd_avg_q_port_number =
301 TOKEN_NUM_INITIALIZER(struct cmd_avg_q_result, port_number,
302 RTE_UINT16);
303 cmdline_parse_token_string_t cmd_avg_q_subport_string =
304 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, subport_string,
305 "subport");
306 cmdline_parse_token_num_t cmd_avg_q_subport_number =
307 TOKEN_NUM_INITIALIZER(struct cmd_avg_q_result, subport_number,
308 RTE_UINT32);
309 cmdline_parse_token_string_t cmd_avg_q_pipe_string =
310 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, pipe_string,
311 "pipe");
312 cmdline_parse_token_num_t cmd_avg_q_pipe_number =
313 TOKEN_NUM_INITIALIZER(struct cmd_avg_q_result, pipe_number,
314 RTE_UINT32);
315 cmdline_parse_token_string_t cmd_avg_q_tc_string =
316 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, tc_string,
317 "tc");
318 cmdline_parse_token_num_t cmd_avg_q_tc_number =
319 TOKEN_NUM_INITIALIZER(struct cmd_avg_q_result, tc_number,
320 RTE_UINT8);
321 cmdline_parse_token_string_t cmd_avg_q_q_string =
322 TOKEN_STRING_INITIALIZER(struct cmd_avg_q_result, q_string,
323 "q");
324 cmdline_parse_token_num_t cmd_avg_q_q_number =
325 TOKEN_NUM_INITIALIZER(struct cmd_avg_q_result, q_number,
326 RTE_UINT8);
327
328 cmdline_parse_inst_t cmd_avg_q = {
329 .f = cmd_avg_q_parsed,
330 .data = NULL,
331 .help_str = "Show pipe stats.",
332 .tokens = {
333 (void *)&cmd_avg_q_qavg_string,
334 (void *)&cmd_avg_q_port_string,
335 (void *)&cmd_avg_q_port_number,
336 (void *)&cmd_avg_q_subport_string,
337 (void *)&cmd_avg_q_subport_number,
338 (void *)&cmd_avg_q_pipe_string,
339 (void *)&cmd_avg_q_pipe_number,
340 (void *)&cmd_avg_q_tc_string,
341 (void *)&cmd_avg_q_tc_number,
342 (void *)&cmd_avg_q_q_string,
343 (void *)&cmd_avg_q_q_number,
344 NULL,
345 },
346 };
347
348 /* *** SHOW AVERAGE QUEUE SIZE (tc/pipe) *** */
349 struct cmd_avg_tcpipe_result {
350 cmdline_fixed_string_t qavg_string;
351 cmdline_fixed_string_t port_string;
352 uint16_t port_number;
353 cmdline_fixed_string_t subport_string;
354 uint32_t subport_number;
355 cmdline_fixed_string_t pipe_string;
356 uint32_t pipe_number;
357 cmdline_fixed_string_t tc_string;
358 uint8_t tc_number;
359 };
360
cmd_avg_tcpipe_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)361 static void cmd_avg_tcpipe_parsed(void *parsed_result,
362 __rte_unused struct cmdline *cl,
363 __rte_unused void *data)
364 {
365 struct cmd_avg_tcpipe_result *res = parsed_result;
366
367 if (qavg_tcpipe(res->port_number, res->subport_number, res->pipe_number, res->tc_number) < 0)
368 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
369 }
370
371 cmdline_parse_token_string_t cmd_avg_tcpipe_qavg_string =
372 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcpipe_result, qavg_string,
373 "qavg");
374 cmdline_parse_token_string_t cmd_avg_tcpipe_port_string =
375 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcpipe_result, port_string,
376 "port");
377 cmdline_parse_token_num_t cmd_avg_tcpipe_port_number =
378 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcpipe_result, port_number,
379 RTE_UINT16);
380 cmdline_parse_token_string_t cmd_avg_tcpipe_subport_string =
381 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcpipe_result, subport_string,
382 "subport");
383 cmdline_parse_token_num_t cmd_avg_tcpipe_subport_number =
384 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcpipe_result, subport_number,
385 RTE_UINT32);
386 cmdline_parse_token_string_t cmd_avg_tcpipe_pipe_string =
387 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcpipe_result, pipe_string,
388 "pipe");
389 cmdline_parse_token_num_t cmd_avg_tcpipe_pipe_number =
390 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcpipe_result, pipe_number,
391 RTE_UINT32);
392 cmdline_parse_token_string_t cmd_avg_tcpipe_tc_string =
393 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcpipe_result, tc_string,
394 "tc");
395 cmdline_parse_token_num_t cmd_avg_tcpipe_tc_number =
396 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcpipe_result, tc_number,
397 RTE_UINT8);
398
399 cmdline_parse_inst_t cmd_avg_tcpipe = {
400 .f = cmd_avg_tcpipe_parsed,
401 .data = NULL,
402 .help_str = "Show pipe stats.",
403 .tokens = {
404 (void *)&cmd_avg_tcpipe_qavg_string,
405 (void *)&cmd_avg_tcpipe_port_string,
406 (void *)&cmd_avg_tcpipe_port_number,
407 (void *)&cmd_avg_tcpipe_subport_string,
408 (void *)&cmd_avg_tcpipe_subport_number,
409 (void *)&cmd_avg_tcpipe_pipe_string,
410 (void *)&cmd_avg_tcpipe_pipe_number,
411 (void *)&cmd_avg_tcpipe_tc_string,
412 (void *)&cmd_avg_tcpipe_tc_number,
413 NULL,
414 },
415 };
416
417 /* *** SHOW AVERAGE QUEUE SIZE (pipe) *** */
418 struct cmd_avg_pipe_result {
419 cmdline_fixed_string_t qavg_string;
420 cmdline_fixed_string_t port_string;
421 uint16_t port_number;
422 cmdline_fixed_string_t subport_string;
423 uint32_t subport_number;
424 cmdline_fixed_string_t pipe_string;
425 uint32_t pipe_number;
426 };
427
cmd_avg_pipe_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)428 static void cmd_avg_pipe_parsed(void *parsed_result,
429 __rte_unused struct cmdline *cl,
430 __rte_unused void *data)
431 {
432 struct cmd_avg_pipe_result *res = parsed_result;
433
434 if (qavg_pipe(res->port_number, res->subport_number, res->pipe_number) < 0)
435 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
436 }
437
438 cmdline_parse_token_string_t cmd_avg_pipe_qavg_string =
439 TOKEN_STRING_INITIALIZER(struct cmd_avg_pipe_result, qavg_string,
440 "qavg");
441 cmdline_parse_token_string_t cmd_avg_pipe_port_string =
442 TOKEN_STRING_INITIALIZER(struct cmd_avg_pipe_result, port_string,
443 "port");
444 cmdline_parse_token_num_t cmd_avg_pipe_port_number =
445 TOKEN_NUM_INITIALIZER(struct cmd_avg_pipe_result, port_number,
446 RTE_UINT16);
447 cmdline_parse_token_string_t cmd_avg_pipe_subport_string =
448 TOKEN_STRING_INITIALIZER(struct cmd_avg_pipe_result, subport_string,
449 "subport");
450 cmdline_parse_token_num_t cmd_avg_pipe_subport_number =
451 TOKEN_NUM_INITIALIZER(struct cmd_avg_pipe_result, subport_number,
452 RTE_UINT32);
453 cmdline_parse_token_string_t cmd_avg_pipe_pipe_string =
454 TOKEN_STRING_INITIALIZER(struct cmd_avg_pipe_result, pipe_string,
455 "pipe");
456 cmdline_parse_token_num_t cmd_avg_pipe_pipe_number =
457 TOKEN_NUM_INITIALIZER(struct cmd_avg_pipe_result, pipe_number,
458 RTE_UINT32);
459
460 cmdline_parse_inst_t cmd_avg_pipe = {
461 .f = cmd_avg_pipe_parsed,
462 .data = NULL,
463 .help_str = "Show pipe stats.",
464 .tokens = {
465 (void *)&cmd_avg_pipe_qavg_string,
466 (void *)&cmd_avg_pipe_port_string,
467 (void *)&cmd_avg_pipe_port_number,
468 (void *)&cmd_avg_pipe_subport_string,
469 (void *)&cmd_avg_pipe_subport_number,
470 (void *)&cmd_avg_pipe_pipe_string,
471 (void *)&cmd_avg_pipe_pipe_number,
472 NULL,
473 },
474 };
475
476 /* *** SHOW AVERAGE QUEUE SIZE (tc/subport) *** */
477 struct cmd_avg_tcsubport_result {
478 cmdline_fixed_string_t qavg_string;
479 cmdline_fixed_string_t port_string;
480 uint16_t port_number;
481 cmdline_fixed_string_t subport_string;
482 uint32_t subport_number;
483 cmdline_fixed_string_t tc_string;
484 uint8_t tc_number;
485 };
486
cmd_avg_tcsubport_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)487 static void cmd_avg_tcsubport_parsed(void *parsed_result,
488 __rte_unused struct cmdline *cl,
489 __rte_unused void *data)
490 {
491 struct cmd_avg_tcsubport_result *res = parsed_result;
492
493 if (qavg_tcsubport(res->port_number, res->subport_number, res->tc_number) < 0)
494 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
495 }
496
497 cmdline_parse_token_string_t cmd_avg_tcsubport_qavg_string =
498 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcsubport_result, qavg_string,
499 "qavg");
500 cmdline_parse_token_string_t cmd_avg_tcsubport_port_string =
501 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcsubport_result, port_string,
502 "port");
503 cmdline_parse_token_num_t cmd_avg_tcsubport_port_number =
504 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcsubport_result, port_number,
505 RTE_UINT16);
506 cmdline_parse_token_string_t cmd_avg_tcsubport_subport_string =
507 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcsubport_result, subport_string,
508 "subport");
509 cmdline_parse_token_num_t cmd_avg_tcsubport_subport_number =
510 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcsubport_result, subport_number,
511 RTE_UINT32);
512 cmdline_parse_token_string_t cmd_avg_tcsubport_tc_string =
513 TOKEN_STRING_INITIALIZER(struct cmd_avg_tcsubport_result, tc_string,
514 "tc");
515 cmdline_parse_token_num_t cmd_avg_tcsubport_tc_number =
516 TOKEN_NUM_INITIALIZER(struct cmd_avg_tcsubport_result, tc_number,
517 RTE_UINT8);
518
519 cmdline_parse_inst_t cmd_avg_tcsubport = {
520 .f = cmd_avg_tcsubport_parsed,
521 .data = NULL,
522 .help_str = "Show pipe stats.",
523 .tokens = {
524 (void *)&cmd_avg_tcsubport_qavg_string,
525 (void *)&cmd_avg_tcsubport_port_string,
526 (void *)&cmd_avg_tcsubport_port_number,
527 (void *)&cmd_avg_tcsubport_subport_string,
528 (void *)&cmd_avg_tcsubport_subport_number,
529 (void *)&cmd_avg_tcsubport_tc_string,
530 (void *)&cmd_avg_tcsubport_tc_number,
531 NULL,
532 },
533 };
534
535 /* *** SHOW AVERAGE QUEUE SIZE (subport) *** */
536 struct cmd_avg_subport_result {
537 cmdline_fixed_string_t qavg_string;
538 cmdline_fixed_string_t port_string;
539 uint16_t port_number;
540 cmdline_fixed_string_t subport_string;
541 uint32_t subport_number;
542 };
543
cmd_avg_subport_parsed(void * parsed_result,__rte_unused struct cmdline * cl,__rte_unused void * data)544 static void cmd_avg_subport_parsed(void *parsed_result,
545 __rte_unused struct cmdline *cl,
546 __rte_unused void *data)
547 {
548 struct cmd_avg_subport_result *res = parsed_result;
549
550 if (qavg_subport(res->port_number, res->subport_number) < 0)
551 printf ("\nStats not available for these parameters. Check that both the port and subport are correct.\n\n");
552 }
553
554 cmdline_parse_token_string_t cmd_avg_subport_qavg_string =
555 TOKEN_STRING_INITIALIZER(struct cmd_avg_subport_result, qavg_string,
556 "qavg");
557 cmdline_parse_token_string_t cmd_avg_subport_port_string =
558 TOKEN_STRING_INITIALIZER(struct cmd_avg_subport_result, port_string,
559 "port");
560 cmdline_parse_token_num_t cmd_avg_subport_port_number =
561 TOKEN_NUM_INITIALIZER(struct cmd_avg_subport_result, port_number,
562 RTE_UINT16);
563 cmdline_parse_token_string_t cmd_avg_subport_subport_string =
564 TOKEN_STRING_INITIALIZER(struct cmd_avg_subport_result, subport_string,
565 "subport");
566 cmdline_parse_token_num_t cmd_avg_subport_subport_number =
567 TOKEN_NUM_INITIALIZER(struct cmd_avg_subport_result, subport_number,
568 RTE_UINT32);
569
570 cmdline_parse_inst_t cmd_avg_subport = {
571 .f = cmd_avg_subport_parsed,
572 .data = NULL,
573 .help_str = "Show pipe stats.",
574 .tokens = {
575 (void *)&cmd_avg_subport_qavg_string,
576 (void *)&cmd_avg_subport_port_string,
577 (void *)&cmd_avg_subport_port_number,
578 (void *)&cmd_avg_subport_subport_string,
579 (void *)&cmd_avg_subport_subport_number,
580 NULL,
581 },
582 };
583
584 /* ******************************************************************************** */
585
586 /* list of instructions */
587 cmdline_parse_ctx_t main_ctx[] = {
588 (cmdline_parse_inst_t *)&cmd_help,
589 (cmdline_parse_inst_t *)&cmd_setqavg,
590 (cmdline_parse_inst_t *)&cmd_appstats,
591 (cmdline_parse_inst_t *)&cmd_subportstats,
592 (cmdline_parse_inst_t *)&cmd_pipestats,
593 (cmdline_parse_inst_t *)&cmd_avg_q,
594 (cmdline_parse_inst_t *)&cmd_avg_tcpipe,
595 (cmdline_parse_inst_t *)&cmd_avg_pipe,
596 (cmdline_parse_inst_t *)&cmd_avg_tcsubport,
597 (cmdline_parse_inst_t *)&cmd_avg_subport,
598 (cmdline_parse_inst_t *)&cmd_quit,
599 NULL,
600 };
601
602 /* prompt function, called from main on MAIN lcore */
603 void
prompt(void)604 prompt(void)
605 {
606 struct cmdline *cl;
607
608 cl = cmdline_stdin_new(main_ctx, "qos_sched> ");
609 if (cl == NULL) {
610 return;
611 }
612 cmdline_interact(cl);
613 cmdline_stdin_exit(cl);
614 }
615