1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2020 Intel Corporation
10 #include <rte_common.h>
11 #include <rte_ethdev.h>
12 #include <rte_swx_port_ethdev.h>
13 #include <rte_swx_port_source_sink.h>
14 #include <rte_swx_pipeline.h>
15 #include <rte_swx_ctl.h>
22 #ifndef CMD_MAX_TOKENS
23 #define CMD_MAX_TOKENS 256
26 #define MSG_OUT_OF_MEMORY "Not enough memory.\n"
27 #define MSG_CMD_UNKNOWN "Unknown command \"%s\".\n"
28 #define MSG_CMD_UNIMPLEM "Command \"%s\" not implemented.\n"
29 #define MSG_ARG_NOT_ENOUGH "Not enough arguments for command \"%s\".\n"
30 #define MSG_ARG_TOO_MANY "Too many arguments for command \"%s\".\n"
31 #define MSG_ARG_MISMATCH "Wrong number of arguments for command \"%s\".\n"
32 #define MSG_ARG_NOT_FOUND "Argument \"%s\" not found.\n"
33 #define MSG_ARG_INVALID "Invalid value for argument \"%s\".\n"
34 #define MSG_FILE_ERR "Error in file \"%s\" at line %u.\n"
35 #define MSG_FILE_NOT_ENOUGH "Not enough rules in file \"%s\".\n"
36 #define MSG_CMD_FAIL "Command \"%s\" failed.\n"
38 #define skip_white_spaces(pos) \
40 __typeof__(pos) _p = (pos); \
41 for ( ; isspace(*_p); _p++) \
47 parser_read_uint64(uint64_t *value, const char *p)
52 p = skip_white_spaces(p);
56 val = strtoul(p, &next, 10);
78 p = skip_white_spaces(p);
87 parser_read_uint32(uint32_t *value, const char *p)
90 int ret = parser_read_uint64(&val, p);
103 parser_read_uint16(uint16_t *value, const char *p)
106 int ret = parser_read_uint64(&val, p);
111 if (val > UINT16_MAX)
118 #define PARSE_DELIMITER " \f\n\r\t\v"
121 parse_tokenize_string(char *string, char *tokens[], uint32_t *n_tokens)
125 if ((string == NULL) ||
130 for (i = 0; i < *n_tokens; i++) {
131 tokens[i] = strtok_r(string, PARSE_DELIMITER, &string);
132 if (tokens[i] == NULL)
136 if ((i == *n_tokens) && strtok_r(string, PARSE_DELIMITER, &string))
146 if ((strlen(in) && index("!#%;", in[0])) ||
147 (strncmp(in, "//", 2) == 0) ||
148 (strncmp(in, "--", 2) == 0))
154 static const char cmd_mempool_help[] =
155 "mempool <mempool_name>\n"
156 " buffer <buffer_size>\n"
157 " pool <pool_size>\n"
158 " cache <cache_size>\n"
162 cmd_mempool(char **tokens,
168 struct mempool_params p;
170 struct mempool *mempool;
172 if (n_tokens != 10) {
173 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
179 if (strcmp(tokens[2], "buffer") != 0) {
180 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buffer");
184 if (parser_read_uint32(&p.buffer_size, tokens[3]) != 0) {
185 snprintf(out, out_size, MSG_ARG_INVALID, "buffer_size");
189 if (strcmp(tokens[4], "pool") != 0) {
190 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pool");
194 if (parser_read_uint32(&p.pool_size, tokens[5]) != 0) {
195 snprintf(out, out_size, MSG_ARG_INVALID, "pool_size");
199 if (strcmp(tokens[6], "cache") != 0) {
200 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cache");
204 if (parser_read_uint32(&p.cache_size, tokens[7]) != 0) {
205 snprintf(out, out_size, MSG_ARG_INVALID, "cache_size");
209 if (strcmp(tokens[8], "cpu") != 0) {
210 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu");
214 if (parser_read_uint32(&p.cpu_id, tokens[9]) != 0) {
215 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id");
219 mempool = mempool_create(obj, name, &p);
220 if (mempool == NULL) {
221 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
226 static const char cmd_link_help[] =
228 " dev <device_name> | port <port_id>\n"
229 " rxq <n_queues> <queue_size> <mempool_name>\n"
230 " txq <n_queues> <queue_size>\n"
231 " promiscuous on | off\n"
232 " [rss <qid_0> ... <qid_n>]\n";
235 cmd_link(char **tokens,
241 struct link_params p;
242 struct link_params_rss rss;
246 memset(&p, 0, sizeof(p));
248 if ((n_tokens < 13) || (n_tokens > 14 + LINK_RXQ_RSS_MAX)) {
249 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
254 if (strcmp(tokens[2], "dev") == 0)
255 p.dev_name = tokens[3];
256 else if (strcmp(tokens[2], "port") == 0) {
259 if (parser_read_uint16(&p.port_id, tokens[3]) != 0) {
260 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
264 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dev or port");
268 if (strcmp(tokens[4], "rxq") != 0) {
269 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
273 if (parser_read_uint32(&p.rx.n_queues, tokens[5]) != 0) {
274 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
277 if (parser_read_uint32(&p.rx.queue_size, tokens[6]) != 0) {
278 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
282 p.rx.mempool_name = tokens[7];
284 if (strcmp(tokens[8], "txq") != 0) {
285 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
289 if (parser_read_uint32(&p.tx.n_queues, tokens[9]) != 0) {
290 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues");
294 if (parser_read_uint32(&p.tx.queue_size, tokens[10]) != 0) {
295 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size");
299 if (strcmp(tokens[11], "promiscuous") != 0) {
300 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "promiscuous");
304 if (strcmp(tokens[12], "on") == 0)
306 else if (strcmp(tokens[12], "off") == 0)
309 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "on or off");
316 uint32_t queue_id, i;
318 if (strcmp(tokens[13], "rss") != 0) {
319 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rss");
326 for (i = 14; i < n_tokens; i++) {
327 if (parser_read_uint32(&queue_id, tokens[i]) != 0) {
328 snprintf(out, out_size, MSG_ARG_INVALID,
333 rss.queue_id[rss.n_queues] = queue_id;
338 link = link_create(obj, name, &p);
340 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]);
345 /* Print the link stats and info */
347 print_link_info(struct link *link, char *out, size_t out_size)
349 struct rte_eth_stats stats;
350 struct rte_ether_addr mac_addr;
351 struct rte_eth_link eth_link;
355 memset(&stats, 0, sizeof(stats));
356 rte_eth_stats_get(link->port_id, &stats);
358 ret = rte_eth_macaddr_get(link->port_id, &mac_addr);
360 snprintf(out, out_size, "\n%s: MAC address get failed: %s",
361 link->name, rte_strerror(-ret));
365 ret = rte_eth_link_get(link->port_id, ð_link);
367 snprintf(out, out_size, "\n%s: link get failed: %s",
368 link->name, rte_strerror(-ret));
372 rte_eth_dev_get_mtu(link->port_id, &mtu);
374 snprintf(out, out_size,
376 "%s: flags=<%s> mtu %u\n"
377 "\tether %02X:%02X:%02X:%02X:%02X:%02X rxqueues %u txqueues %u\n"
378 "\tport# %u speed %s\n"
379 "\tRX packets %" PRIu64" bytes %" PRIu64"\n"
380 "\tRX errors %" PRIu64" missed %" PRIu64" no-mbuf %" PRIu64"\n"
381 "\tTX packets %" PRIu64" bytes %" PRIu64"\n"
382 "\tTX errors %" PRIu64"\n",
384 eth_link.link_status == 0 ? "DOWN" : "UP",
386 mac_addr.addr_bytes[0], mac_addr.addr_bytes[1],
387 mac_addr.addr_bytes[2], mac_addr.addr_bytes[3],
388 mac_addr.addr_bytes[4], mac_addr.addr_bytes[5],
392 rte_eth_link_speed_to_str(eth_link.link_speed),
404 * link show [<link_name>]
407 cmd_link_show(char **tokens,
416 if (n_tokens != 2 && n_tokens != 3) {
417 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
422 link = link_next(obj, NULL);
424 while (link != NULL) {
425 out_size = out_size - strlen(out);
426 out = &out[strlen(out)];
428 print_link_info(link, out, out_size);
429 link = link_next(obj, link);
432 out_size = out_size - strlen(out);
433 out = &out[strlen(out)];
435 link_name = tokens[2];
436 link = link_find(obj, link_name);
439 snprintf(out, out_size, MSG_ARG_INVALID,
440 "Link does not exist");
443 print_link_info(link, out, out_size);
447 static const char cmd_pipeline_create_help[] =
448 "pipeline <pipeline_name> create <numa_node>\n";
451 cmd_pipeline_create(char **tokens,
462 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
468 if (parser_read_uint32(&numa_node, tokens[3]) != 0) {
469 snprintf(out, out_size, MSG_ARG_INVALID, "numa_node");
473 p = pipeline_create(obj, name, (int)numa_node);
475 snprintf(out, out_size, "pipeline create error.");
480 static const char cmd_pipeline_port_in_help[] =
481 "pipeline <pipeline_name> port in <port_id>\n"
482 " link <link_name> rxq <queue_id> bsz <burst_size>\n"
483 " source <mempool_name> <fie_name>\n";
486 cmd_pipeline_port_in(char **tokens,
494 uint32_t port_id = 0, t0;
497 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
501 p = pipeline_find(obj, tokens[1]);
503 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
507 if (strcmp(tokens[2], "port") != 0) {
508 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
512 if (strcmp(tokens[3], "in") != 0) {
513 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in");
517 if (parser_read_uint32(&port_id, tokens[4]) != 0) {
518 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
524 if (strcmp(tokens[t0], "link") == 0) {
525 struct rte_swx_port_ethdev_reader_params params;
528 if (n_tokens < t0 + 6) {
529 snprintf(out, out_size, MSG_ARG_MISMATCH,
530 "pipeline port in link");
534 link = link_find(obj, tokens[t0 + 1]);
536 snprintf(out, out_size, MSG_ARG_INVALID,
540 params.dev_name = link->dev_name;
542 if (strcmp(tokens[t0 + 2], "rxq") != 0) {
543 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq");
547 if (parser_read_uint16(¶ms.queue_id, tokens[t0 + 3]) != 0) {
548 snprintf(out, out_size, MSG_ARG_INVALID,
553 if (strcmp(tokens[t0 + 4], "bsz") != 0) {
554 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
558 if (parser_read_uint32(¶ms.burst_size, tokens[t0 + 5])) {
559 snprintf(out, out_size, MSG_ARG_INVALID,
566 status = rte_swx_pipeline_port_in_config(p->p,
570 } else if (strcmp(tokens[t0], "source") == 0) {
571 struct rte_swx_port_source_params params;
574 if (n_tokens < t0 + 3) {
575 snprintf(out, out_size, MSG_ARG_MISMATCH,
576 "pipeline port in source");
580 mp = mempool_find(obj, tokens[t0 + 1]);
582 snprintf(out, out_size, MSG_ARG_INVALID,
588 params.file_name = tokens[t0 + 2];
592 status = rte_swx_pipeline_port_in_config(p->p,
597 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
602 snprintf(out, out_size, "port in error.");
606 if (n_tokens != t0) {
607 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
612 static const char cmd_pipeline_port_out_help[] =
613 "pipeline <pipeline_name> port out <port_id>\n"
614 " link <link_name> txq <txq_id> bsz <burst_size>\n"
615 " | sink <file_name> | none\n";
618 cmd_pipeline_port_out(char **tokens,
626 uint32_t port_id = 0, t0;
629 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
633 p = pipeline_find(obj, tokens[1]);
635 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
639 if (strcmp(tokens[2], "port") != 0) {
640 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port");
644 if (strcmp(tokens[3], "out") != 0) {
645 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out");
649 if (parser_read_uint32(&port_id, tokens[4]) != 0) {
650 snprintf(out, out_size, MSG_ARG_INVALID, "port_id");
656 if (strcmp(tokens[t0], "link") == 0) {
657 struct rte_swx_port_ethdev_writer_params params;
660 if (n_tokens < t0 + 6) {
661 snprintf(out, out_size, MSG_ARG_MISMATCH,
662 "pipeline port out link");
666 link = link_find(obj, tokens[t0 + 1]);
668 snprintf(out, out_size, MSG_ARG_INVALID,
672 params.dev_name = link->dev_name;
674 if (strcmp(tokens[t0 + 2], "txq") != 0) {
675 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq");
679 if (parser_read_uint16(¶ms.queue_id, tokens[t0 + 3]) != 0) {
680 snprintf(out, out_size, MSG_ARG_INVALID,
685 if (strcmp(tokens[t0 + 4], "bsz") != 0) {
686 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz");
690 if (parser_read_uint32(¶ms.burst_size, tokens[t0 + 5])) {
691 snprintf(out, out_size, MSG_ARG_INVALID,
698 status = rte_swx_pipeline_port_out_config(p->p,
702 } else if (strcmp(tokens[t0], "sink") == 0) {
703 struct rte_swx_port_sink_params params;
705 params.file_name = strcmp(tokens[t0 + 1], "none") ?
706 tokens[t0 + 1] : NULL;
710 status = rte_swx_pipeline_port_out_config(p->p,
715 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
720 snprintf(out, out_size, "port out error.");
724 if (n_tokens != t0) {
725 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
730 static const char cmd_pipeline_build_help[] =
731 "pipeline <pipeline_name> build <spec_file>\n";
734 cmd_pipeline_build(char **tokens,
740 struct pipeline *p = NULL;
747 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
751 p = pipeline_find(obj, tokens[1]);
753 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]);
757 spec = fopen(tokens[3], "r");
759 snprintf(out, out_size, "Cannot open file %s.\n", tokens[3]);
763 status = rte_swx_pipeline_build_from_spec(p->p,
769 snprintf(out, out_size, "Error %d at line %u: %s\n.",
770 status, err_line, err_msg);
774 p->ctl = rte_swx_ctl_pipeline_create(p->p);
776 snprintf(out, out_size, "Pipeline control create failed.");
777 rte_swx_pipeline_free(p->p);
782 static const char cmd_pipeline_table_update_help[] =
783 "pipeline <pipeline_name> table <table_name> update <file_name_add> "
784 "<file_name_delete> <file_name_default>";
787 cmd_pipeline_table_update(char **tokens,
794 char *pipeline_name, *table_name, *line = NULL;
795 char *file_name_add, *file_name_delete, *file_name_default;
796 FILE *file_add = NULL, *file_delete = NULL, *file_default = NULL;
801 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
805 pipeline_name = tokens[1];
806 p = pipeline_find(obj, pipeline_name);
808 snprintf(out, out_size, MSG_ARG_INVALID, "pipeline_name");
812 if (strcmp(tokens[2], "table") != 0) {
813 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table");
817 table_name = tokens[3];
819 if (strcmp(tokens[4], "update") != 0) {
820 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "update");
824 file_name_add = tokens[5];
825 file_name_delete = tokens[6];
826 file_name_default = tokens[7];
829 if (strcmp(file_name_add, "none")) {
830 file_add = fopen(file_name_add, "r");
832 snprintf(out, out_size, "Cannot open file %s",
838 if (strcmp(file_name_delete, "none")) {
839 file_delete = fopen(file_name_delete, "r");
841 snprintf(out, out_size, "Cannot open file %s",
847 if (strcmp(file_name_default, "none")) {
848 file_default = fopen(file_name_default, "r");
850 snprintf(out, out_size, "Cannot open file %s",
856 if (!file_add && !file_delete && !file_default) {
857 snprintf(out, out_size, "Nothing to be done.");
861 /* Buffer allocation. */
864 snprintf(out, out_size, MSG_OUT_OF_MEMORY);
870 for (line_id = 1; ; line_id++) {
871 struct rte_swx_table_entry *entry;
873 if (fgets(line, 2048, file_add) == NULL)
876 entry = rte_swx_ctl_pipeline_table_entry_read(p->ctl,
880 snprintf(out, out_size, MSG_FILE_ERR,
881 file_name_add, line_id);
885 status = rte_swx_ctl_pipeline_table_entry_add(p->ctl,
889 snprintf(out, out_size,
890 "Invalid entry in file %s at line %u",
891 file_name_add, line_id);
901 for (line_id = 1; ; line_id++) {
902 struct rte_swx_table_entry *entry;
904 if (fgets(line, 2048, file_delete) == NULL)
907 entry = rte_swx_ctl_pipeline_table_entry_read(p->ctl,
911 snprintf(out, out_size, MSG_FILE_ERR,
912 file_name_delete, line_id);
916 status = rte_swx_ctl_pipeline_table_entry_delete(p->ctl,
920 snprintf(out, out_size,
921 "Invalid entry in file %s at line %u",
922 file_name_delete, line_id);
932 for (line_id = 1; ; line_id++) {
933 struct rte_swx_table_entry *entry;
935 if (fgets(line, 2048, file_default) == NULL)
938 entry = rte_swx_ctl_pipeline_table_entry_read(p->ctl,
942 snprintf(out, out_size, MSG_FILE_ERR,
943 file_name_default, line_id);
947 status = rte_swx_ctl_pipeline_table_default_entry_add(p->ctl,
951 snprintf(out, out_size,
952 "Invalid entry in file %s at line %u",
953 file_name_default, line_id);
958 fclose(file_default);
961 status = rte_swx_ctl_pipeline_commit(p->ctl, 1);
963 snprintf(out, out_size, "Commit failed.");
969 rte_swx_ctl_pipeline_table_fprintf(stdout, p->ctl, table_name);
974 rte_swx_ctl_pipeline_abort(p->ctl);
981 fclose(file_default);
984 static const char cmd_pipeline_stats_help[] =
985 "pipeline <pipeline_name> stats\n";
988 cmd_pipeline_stats(char **tokens,
994 struct rte_swx_ctl_pipeline_info info;
1000 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1004 p = pipeline_find(obj, tokens[1]);
1005 if (!p || !p->ctl) {
1006 snprintf(out, out_size, MSG_ARG_INVALID, "pipeline_name");
1010 if (strcmp(tokens[2], "stats")) {
1011 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats");
1015 status = rte_swx_ctl_pipeline_info_get(p->p, &info);
1017 snprintf(out, out_size, "Pipeline info get error.");
1021 snprintf(out, out_size, "Input ports:\n");
1022 out_size -= strlen(out);
1025 for (i = 0; i < info.n_ports_in; i++) {
1026 struct rte_swx_port_in_stats stats;
1028 rte_swx_ctl_pipeline_port_in_stats_read(p->p, i, &stats);
1030 snprintf(out, out_size, "\tPort %u:"
1033 " empty %" PRIu64 "\n",
1034 i, stats.n_pkts, stats.n_bytes, stats.n_empty);
1035 out_size -= strlen(out);
1039 snprintf(out, out_size, "Output ports:\n");
1040 out_size -= strlen(out);
1043 for (i = 0; i < info.n_ports_out; i++) {
1044 struct rte_swx_port_out_stats stats;
1046 rte_swx_ctl_pipeline_port_out_stats_read(p->p, i, &stats);
1048 snprintf(out, out_size, "\tPort %u:"
1050 " bytes %" PRIu64 "\n",
1051 i, stats.n_pkts, stats.n_bytes);
1052 out_size -= strlen(out);
1057 static const char cmd_thread_pipeline_enable_help[] =
1058 "thread <thread_id> pipeline <pipeline_name> enable\n";
1061 cmd_thread_pipeline_enable(char **tokens,
1067 char *pipeline_name;
1072 if (n_tokens != 5) {
1073 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1077 if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
1078 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
1082 if (strcmp(tokens[2], "pipeline") != 0) {
1083 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
1087 pipeline_name = tokens[3];
1088 p = pipeline_find(obj, pipeline_name);
1089 if (!p || !p->ctl) {
1090 snprintf(out, out_size, MSG_ARG_INVALID, "pipeline_name");
1094 if (strcmp(tokens[4], "enable") != 0) {
1095 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable");
1099 status = thread_pipeline_enable(thread_id, obj, pipeline_name);
1101 snprintf(out, out_size, MSG_CMD_FAIL, "thread pipeline enable");
1106 static const char cmd_thread_pipeline_disable_help[] =
1107 "thread <thread_id> pipeline <pipeline_name> disable\n";
1110 cmd_thread_pipeline_disable(char **tokens,
1117 char *pipeline_name;
1121 if (n_tokens != 5) {
1122 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]);
1126 if (parser_read_uint32(&thread_id, tokens[1]) != 0) {
1127 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id");
1131 if (strcmp(tokens[2], "pipeline") != 0) {
1132 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline");
1136 pipeline_name = tokens[3];
1137 p = pipeline_find(obj, pipeline_name);
1138 if (!p || !p->ctl) {
1139 snprintf(out, out_size, MSG_ARG_INVALID, "pipeline_name");
1143 if (strcmp(tokens[4], "disable") != 0) {
1144 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable");
1148 status = thread_pipeline_disable(thread_id, obj, pipeline_name);
1150 snprintf(out, out_size, MSG_CMD_FAIL,
1151 "thread pipeline disable");
1157 cmd_help(char **tokens,
1161 void *arg __rte_unused)
1166 if (n_tokens == 0) {
1167 snprintf(out, out_size,
1168 "Type 'help <command>' for command details.\n\n");
1172 if (strcmp(tokens[0], "mempool") == 0) {
1173 snprintf(out, out_size, "\n%s\n", cmd_mempool_help);
1177 if (strcmp(tokens[0], "link") == 0) {
1178 snprintf(out, out_size, "\n%s\n", cmd_link_help);
1182 if ((strcmp(tokens[0], "pipeline") == 0) &&
1183 ((n_tokens == 1) && (strcmp(tokens[2], "create")) == 0)) {
1184 snprintf(out, out_size, "\n%s\n", cmd_pipeline_create_help);
1188 if ((strcmp(tokens[0], "pipeline") == 0) &&
1189 (strcmp(tokens[1], "port") == 0)) {
1190 if ((n_tokens == 3) && (strcmp(tokens[2], "in")) == 0) {
1191 snprintf(out, out_size, "\n%s\n",
1192 cmd_pipeline_port_in_help);
1196 if ((n_tokens == 3) && (strcmp(tokens[2], "out")) == 0) {
1197 snprintf(out, out_size, "\n%s\n",
1198 cmd_pipeline_port_out_help);
1203 if ((strcmp(tokens[0], "pipeline") == 0) &&
1204 ((n_tokens >= 2) && (strcmp(tokens[2], "build")) == 0)) {
1205 snprintf(out, out_size, "\n%s\n", cmd_pipeline_build_help);
1209 if ((strcmp(tokens[0], "pipeline") == 0) &&
1210 ((n_tokens >= 2) && (strcmp(tokens[2], "table")) == 0)) {
1211 snprintf(out, out_size, "\n%s\n",
1212 cmd_pipeline_table_update_help);
1216 if ((strcmp(tokens[0], "pipeline") == 0) &&
1217 ((n_tokens >= 2) && (strcmp(tokens[2], "stats")) == 0)) {
1218 snprintf(out, out_size, "\n%s\n", cmd_pipeline_stats_help);
1222 if ((n_tokens == 3) &&
1223 (strcmp(tokens[0], "thread") == 0) &&
1224 (strcmp(tokens[1], "pipeline") == 0)) {
1225 if (strcmp(tokens[2], "enable") == 0) {
1226 snprintf(out, out_size, "\n%s\n",
1227 cmd_thread_pipeline_enable_help);
1231 if (strcmp(tokens[2], "disable") == 0) {
1232 snprintf(out, out_size, "\n%s\n",
1233 cmd_thread_pipeline_disable_help);
1238 snprintf(out, out_size, "Invalid command\n");
1242 cli_process(char *in, char *out, size_t out_size, void *obj)
1244 char *tokens[CMD_MAX_TOKENS];
1245 uint32_t n_tokens = RTE_DIM(tokens);
1251 status = parse_tokenize_string(in, tokens, &n_tokens);
1253 snprintf(out, out_size, MSG_ARG_TOO_MANY, "");
1260 if (strcmp(tokens[0], "help") == 0) {
1261 cmd_help(tokens, n_tokens, out, out_size, obj);
1265 if (strcmp(tokens[0], "mempool") == 0) {
1266 cmd_mempool(tokens, n_tokens, out, out_size, obj);
1270 if (strcmp(tokens[0], "link") == 0) {
1271 if (strcmp(tokens[1], "show") == 0) {
1272 cmd_link_show(tokens, n_tokens, out, out_size, obj);
1276 cmd_link(tokens, n_tokens, out, out_size, obj);
1280 if (strcmp(tokens[0], "pipeline") == 0) {
1281 if ((n_tokens >= 3) &&
1282 (strcmp(tokens[2], "create") == 0)) {
1283 cmd_pipeline_create(tokens, n_tokens, out, out_size,
1288 if ((n_tokens >= 4) &&
1289 (strcmp(tokens[2], "port") == 0) &&
1290 (strcmp(tokens[3], "in") == 0)) {
1291 cmd_pipeline_port_in(tokens, n_tokens, out, out_size,
1296 if ((n_tokens >= 4) &&
1297 (strcmp(tokens[2], "port") == 0) &&
1298 (strcmp(tokens[3], "out") == 0)) {
1299 cmd_pipeline_port_out(tokens, n_tokens, out, out_size,
1304 if ((n_tokens >= 3) &&
1305 (strcmp(tokens[2], "build") == 0)) {
1306 cmd_pipeline_build(tokens, n_tokens, out, out_size,
1311 if ((n_tokens >= 3) &&
1312 (strcmp(tokens[2], "table") == 0)) {
1313 cmd_pipeline_table_update(tokens, n_tokens, out,
1318 if ((n_tokens >= 3) &&
1319 (strcmp(tokens[2], "stats") == 0)) {
1320 cmd_pipeline_stats(tokens, n_tokens, out, out_size,
1326 if (strcmp(tokens[0], "thread") == 0) {
1327 if ((n_tokens >= 5) &&
1328 (strcmp(tokens[4], "enable") == 0)) {
1329 cmd_thread_pipeline_enable(tokens, n_tokens,
1330 out, out_size, obj);
1334 if ((n_tokens >= 5) &&
1335 (strcmp(tokens[4], "disable") == 0)) {
1336 cmd_thread_pipeline_disable(tokens, n_tokens,
1337 out, out_size, obj);
1342 snprintf(out, out_size, MSG_CMD_UNKNOWN, tokens[0]);
1346 cli_script_process(const char *file_name,
1347 size_t msg_in_len_max,
1348 size_t msg_out_len_max,
1351 char *msg_in = NULL, *msg_out = NULL;
1354 /* Check input arguments */
1355 if ((file_name == NULL) ||
1356 (strlen(file_name) == 0) ||
1357 (msg_in_len_max == 0) ||
1358 (msg_out_len_max == 0))
1361 msg_in = malloc(msg_in_len_max + 1);
1362 msg_out = malloc(msg_out_len_max + 1);
1363 if ((msg_in == NULL) ||
1364 (msg_out == NULL)) {
1370 /* Open input file */
1371 f = fopen(file_name, "r");
1380 if (fgets(msg_in, msg_in_len_max + 1, f) == NULL)
1383 printf("%s", msg_in);
1391 if (strlen(msg_out))
1392 printf("%s", msg_out);