mbuf: remove the rte_pktmbuf structure
[dpdk.git] / app / test / commands.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   Copyright(c) 2014 6WIND S.A.
6  *   All rights reserved.
7  *
8  *   Redistribution and use in source and binary forms, with or without
9  *   modification, are permitted provided that the following conditions
10  *   are met:
11  *
12  *     * Redistributions of source code must retain the above copyright
13  *       notice, this list of conditions and the following disclaimer.
14  *     * Redistributions in binary form must reproduce the above copyright
15  *       notice, this list of conditions and the following disclaimer in
16  *       the documentation and/or other materials provided with the
17  *       distribution.
18  *     * Neither the name of Intel Corporation nor the names of its
19  *       contributors may be used to endorse or promote products derived
20  *       from this software without specific prior written permission.
21  *
22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #include <stdio.h>
36 #include <stdarg.h>
37 #include <stdint.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <netinet/in.h>
41 #include <termios.h>
42 #ifndef __linux__
43 #ifndef __FreeBSD__
44 #include <net/socket.h>
45 #endif
46 #endif
47 #include <inttypes.h>
48 #include <errno.h>
49 #include <sys/queue.h>
50
51 #include <rte_common.h>
52 #include <rte_log.h>
53 #include <rte_debug.h>
54 #include <rte_memory.h>
55 #include <rte_memcpy.h>
56 #include <rte_memzone.h>
57 #include <rte_launch.h>
58 #include <rte_cycles.h>
59 #include <rte_tailq.h>
60 #include <rte_eal.h>
61 #include <rte_per_lcore.h>
62 #include <rte_lcore.h>
63 #include <rte_atomic.h>
64 #include <rte_branch_prediction.h>
65 #include <rte_ring.h>
66 #include <rte_mempool.h>
67 #include <rte_mbuf.h>
68 #include <rte_devargs.h>
69
70 #include <cmdline_rdline.h>
71 #include <cmdline_parse.h>
72 #include <cmdline_parse_ipaddr.h>
73 #include <cmdline_parse_num.h>
74 #include <cmdline_parse_string.h>
75 #include <cmdline.h>
76
77 #include "test.h"
78
79 /****************/
80
81 static struct test_commands_list commands_list =
82         TAILQ_HEAD_INITIALIZER(commands_list);
83
84 void
85 add_test_command(struct test_command *t)
86 {
87         TAILQ_INSERT_TAIL(&commands_list, t, next);
88 }
89
90 struct cmd_autotest_result {
91         cmdline_fixed_string_t autotest;
92 };
93
94 static void cmd_autotest_parsed(void *parsed_result,
95                                 __attribute__((unused)) struct cmdline *cl,
96                                 __attribute__((unused)) void *data)
97 {
98         struct test_command *t;
99         struct cmd_autotest_result *res = parsed_result;
100         int ret = 0;
101
102         TAILQ_FOREACH(t, &commands_list, next) {
103                 if (!strcmp(res->autotest, t->command))
104                         ret = t->callback();
105         }
106
107         if (ret == 0)
108                 printf("Test OK\n");
109         else
110                 printf("Test Failed\n");
111         fflush(stdout);
112 }
113
114 cmdline_parse_token_string_t cmd_autotest_autotest =
115         TOKEN_STRING_INITIALIZER(struct cmd_autotest_result, autotest,
116                                  "");
117
118 cmdline_parse_inst_t cmd_autotest = {
119         .f = cmd_autotest_parsed,  /* function to call */
120         .data = NULL,      /* 2nd arg of func */
121         .help_str = "launch autotest",
122         .tokens = {        /* token list, NULL terminated */
123                 (void *)&cmd_autotest_autotest,
124                 NULL,
125         },
126 };
127
128 /****************/
129
130 struct cmd_dump_result {
131         cmdline_fixed_string_t dump;
132 };
133
134 static void
135 dump_struct_sizes(void)
136 {
137 #define DUMP_SIZE(t) printf("sizeof(" #t ") = %u\n", (unsigned)sizeof(t));
138         DUMP_SIZE(struct rte_mbuf);
139         DUMP_SIZE(struct rte_mempool);
140         DUMP_SIZE(struct rte_ring);
141 #undef DUMP_SIZE
142 }
143
144 static void cmd_dump_parsed(void *parsed_result,
145                             __attribute__((unused)) struct cmdline *cl,
146                             __attribute__((unused)) void *data)
147 {
148         struct cmd_dump_result *res = parsed_result;
149
150         if (!strcmp(res->dump, "dump_physmem"))
151                 rte_dump_physmem_layout(stdout);
152         else if (!strcmp(res->dump, "dump_memzone"))
153                 rte_memzone_dump(stdout);
154         else if (!strcmp(res->dump, "dump_log_history"))
155                 rte_log_dump_history(stdout);
156         else if (!strcmp(res->dump, "dump_struct_sizes"))
157                 dump_struct_sizes();
158         else if (!strcmp(res->dump, "dump_ring"))
159                 rte_ring_list_dump(stdout);
160         else if (!strcmp(res->dump, "dump_mempool"))
161                 rte_mempool_list_dump(stdout);
162         else if (!strcmp(res->dump, "dump_devargs"))
163                 rte_eal_devargs_dump(stdout);
164 }
165
166 cmdline_parse_token_string_t cmd_dump_dump =
167         TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump,
168                                  "dump_physmem#dump_memzone#dump_log_history#"
169                                  "dump_struct_sizes#dump_ring#dump_mempool#"
170                                  "dump_devargs");
171
172 cmdline_parse_inst_t cmd_dump = {
173         .f = cmd_dump_parsed,  /* function to call */
174         .data = NULL,      /* 2nd arg of func */
175         .help_str = "dump status",
176         .tokens = {        /* token list, NULL terminated */
177                 (void *)&cmd_dump_dump,
178                 NULL,
179         },
180 };
181
182 /****************/
183
184 struct cmd_dump_one_result {
185         cmdline_fixed_string_t dump;
186         cmdline_fixed_string_t name;
187 };
188
189 static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl,
190                                 __attribute__((unused)) void *data)
191 {
192         struct cmd_dump_one_result *res = parsed_result;
193
194         if (!strcmp(res->dump, "dump_ring")) {
195                 struct rte_ring *r;
196                 r = rte_ring_lookup(res->name);
197                 if (r == NULL) {
198                         cmdline_printf(cl, "Cannot find ring\n");
199                         return;
200                 }
201                 rte_ring_dump(stdout, r);
202         }
203         else if (!strcmp(res->dump, "dump_mempool")) {
204                 struct rte_mempool *mp;
205                 mp = rte_mempool_lookup(res->name);
206                 if (mp == NULL) {
207                         cmdline_printf(cl, "Cannot find mempool\n");
208                         return;
209                 }
210                 rte_mempool_dump(stdout, mp);
211         }
212 }
213
214 cmdline_parse_token_string_t cmd_dump_one_dump =
215         TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, dump,
216                                  "dump_ring#dump_mempool");
217
218 cmdline_parse_token_string_t cmd_dump_one_name =
219         TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, name, NULL);
220
221 cmdline_parse_inst_t cmd_dump_one = {
222         .f = cmd_dump_one_parsed,  /* function to call */
223         .data = NULL,      /* 2nd arg of func */
224         .help_str = "dump one ring/mempool: dump_ring|dump_mempool <name>",
225         .tokens = {        /* token list, NULL terminated */
226                 (void *)&cmd_dump_one_dump,
227                 (void *)&cmd_dump_one_name,
228                 NULL,
229         },
230 };
231
232 /****************/
233
234 struct cmd_set_ring_result {
235         cmdline_fixed_string_t set;
236         cmdline_fixed_string_t name;
237         uint32_t value;
238 };
239
240 static void cmd_set_ring_parsed(void *parsed_result, struct cmdline *cl,
241                                 __attribute__((unused)) void *data)
242 {
243         struct cmd_set_ring_result *res = parsed_result;
244         struct rte_ring *r;
245         int ret;
246
247         r = rte_ring_lookup(res->name);
248         if (r == NULL) {
249                 cmdline_printf(cl, "Cannot find ring\n");
250                 return;
251         }
252
253         if (!strcmp(res->set, "set_watermark")) {
254                 ret = rte_ring_set_water_mark(r, res->value);
255                 if (ret != 0)
256                         cmdline_printf(cl, "Cannot set water mark\n");
257         }
258 }
259
260 cmdline_parse_token_string_t cmd_set_ring_set =
261         TOKEN_STRING_INITIALIZER(struct cmd_set_ring_result, set,
262                                  "set_watermark");
263
264 cmdline_parse_token_string_t cmd_set_ring_name =
265         TOKEN_STRING_INITIALIZER(struct cmd_set_ring_result, name, NULL);
266
267 cmdline_parse_token_num_t cmd_set_ring_value =
268         TOKEN_NUM_INITIALIZER(struct cmd_set_ring_result, value, UINT32);
269
270 cmdline_parse_inst_t cmd_set_ring = {
271         .f = cmd_set_ring_parsed,  /* function to call */
272         .data = NULL,      /* 2nd arg of func */
273         .help_str = "set watermark: "
274                         "set_watermark <ring_name> <value>",
275         .tokens = {        /* token list, NULL terminated */
276                 (void *)&cmd_set_ring_set,
277                 (void *)&cmd_set_ring_name,
278                 (void *)&cmd_set_ring_value,
279                 NULL,
280         },
281 };
282
283 /****************/
284
285 struct cmd_quit_result {
286         cmdline_fixed_string_t quit;
287 };
288
289 static void
290 cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
291                 struct cmdline *cl,
292                 __attribute__((unused)) void *data)
293 {
294         cmdline_quit(cl);
295 }
296
297 cmdline_parse_token_string_t cmd_quit_quit =
298         TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit,
299                                  "quit");
300
301 cmdline_parse_inst_t cmd_quit = {
302         .f = cmd_quit_parsed,  /* function to call */
303         .data = NULL,      /* 2nd arg of func */
304         .help_str = "exit application",
305         .tokens = {        /* token list, NULL terminated */
306                 (void *)&cmd_quit_quit,
307                 NULL,
308         },
309 };
310
311 /****************/
312
313 cmdline_parse_ctx_t main_ctx[] = {
314         (cmdline_parse_inst_t *)&cmd_autotest,
315         (cmdline_parse_inst_t *)&cmd_dump,
316         (cmdline_parse_inst_t *)&cmd_dump_one,
317         (cmdline_parse_inst_t *)&cmd_set_ring,
318         (cmdline_parse_inst_t *)&cmd_quit,
319         NULL,
320 };
321
322 int commands_init(void)
323 {
324         struct test_command *t;
325         char *commands, *ptr;
326         int commands_len = 0;
327
328         TAILQ_FOREACH(t, &commands_list, next) {
329                 commands_len += strlen(t->command) + 1;
330         }
331
332         commands = malloc(commands_len);
333         if (!commands)
334                 return -1;
335
336         ptr = commands;
337         TAILQ_FOREACH(t, &commands_list, next) {
338                 ptr += sprintf(ptr, "%s#", t->command);
339         }
340         ptr--;
341         ptr[0] = '\0';
342
343         cmd_autotest_autotest.string_data.str = commands;
344         return 0;
345 }