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 24 static void cmd_help_parsed(__attribute__((unused)) void *parsed_result, 25 struct cmdline *cl, 26 __attribute__((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 peiod (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 67 static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result, 68 struct cmdline *cl, 69 __attribute__((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 94 static void cmd_setqavg_parsed(void *parsed_result, 95 __attribute__((unused)) struct cmdline *cl, 96 __attribute__((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 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 136 static void cmd_appstats_parsed(__attribute__((unused)) void *parsed_result, 137 __attribute__((unused)) struct cmdline *cl, 138 __attribute__((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 170 static void cmd_subportstats_parsed(void *parsed_result, 171 __attribute__((unused)) struct cmdline *cl, 172 __attribute__((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 UINT32); 192 cmdline_parse_token_num_t cmd_subportstats_port_number = 193 TOKEN_NUM_INITIALIZER(struct cmd_subportstats_result, port_number, 194 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 221 static void cmd_pipestats_parsed(void *parsed_result, 222 __attribute__((unused)) struct cmdline *cl, 223 __attribute__((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 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 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 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 284 static void cmd_avg_q_parsed(void *parsed_result, 285 __attribute__((unused)) struct cmdline *cl, 286 __attribute__((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 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 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 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 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 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 361 static void cmd_avg_tcpipe_parsed(void *parsed_result, 362 __attribute__((unused)) struct cmdline *cl, 363 __attribute__((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 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 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 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 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 428 static void cmd_avg_pipe_parsed(void *parsed_result, 429 __attribute__((unused)) struct cmdline *cl, 430 __attribute__((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 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 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 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 487 static void cmd_avg_tcsubport_parsed(void *parsed_result, 488 __attribute__((unused)) struct cmdline *cl, 489 __attribute__((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 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 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 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 544 static void cmd_avg_subport_parsed(void *parsed_result, 545 __attribute__((unused)) struct cmdline *cl, 546 __attribute__((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 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 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 MASTER lcore */ 603 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