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 struct cmd_autotest_result { 82 cmdline_fixed_string_t autotest; 83 }; 84 85 static void cmd_autotest_parsed(void *parsed_result, 86 __attribute__((unused)) struct cmdline *cl, 87 __attribute__((unused)) void *data) 88 { 89 struct cmd_autotest_result *res = parsed_result; 90 int ret = 0; 91 92 if (!strcmp(res->autotest, "version_autotest")) 93 ret = test_version(); 94 if (!strcmp(res->autotest, "eal_fs_autotest")) 95 ret = test_eal_fs(); 96 if (!strcmp(res->autotest, "debug_autotest")) 97 ret = test_debug(); 98 if (!strcmp(res->autotest, "pci_autotest")) 99 ret = test_pci(); 100 if (!strcmp(res->autotest, "prefetch_autotest")) 101 ret = test_prefetch(); 102 if (!strcmp(res->autotest, "byteorder_autotest")) 103 ret = test_byteorder(); 104 if (!strcmp(res->autotest, "per_lcore_autotest")) 105 ret = test_per_lcore(); 106 if (!strcmp(res->autotest, "atomic_autotest")) 107 ret = test_atomic(); 108 if (!strcmp(res->autotest, "malloc_autotest")) 109 ret = test_malloc(); 110 if (!strcmp(res->autotest, "spinlock_autotest")) 111 ret = test_spinlock(); 112 if (!strcmp(res->autotest, "memory_autotest")) 113 ret = test_memory(); 114 if (!strcmp(res->autotest, "memzone_autotest")) 115 ret = test_memzone(); 116 if (!strcmp(res->autotest, "rwlock_autotest")) 117 ret = test_rwlock(); 118 if (!strcmp(res->autotest, "mbuf_autotest")) 119 ret = test_mbuf(); 120 if (!strcmp(res->autotest, "logs_autotest")) 121 ret = test_logs(); 122 if (!strcmp(res->autotest, "errno_autotest")) 123 ret = test_errno(); 124 if (!strcmp(res->autotest, "hash_autotest")) 125 ret = test_hash(); 126 if (!strcmp(res->autotest, "hash_perf_autotest")) 127 ret = test_hash_perf(); 128 if (!strcmp(res->autotest, "lpm_autotest")) 129 ret = test_lpm(); 130 if (!strcmp(res->autotest, "lpm6_autotest")) 131 ret = test_lpm6(); 132 if (!strcmp(res->autotest, "cpuflags_autotest")) 133 ret = test_cpuflags(); 134 if (!strcmp(res->autotest, "cmdline_autotest")) 135 ret = test_cmdline(); 136 if (!strcmp(res->autotest, "tailq_autotest")) 137 ret = test_tailq(); 138 if (!strcmp(res->autotest, "multiprocess_autotest")) 139 ret = test_mp_secondary(); 140 if (!strcmp(res->autotest, "memcpy_autotest")) 141 ret = test_memcpy(); 142 if (!strcmp(res->autotest, "string_autotest")) 143 ret = test_string_fns(); 144 if (!strcmp(res->autotest, "eal_flags_autotest")) 145 ret = test_eal_flags(); 146 if (!strcmp(res->autotest, "alarm_autotest")) 147 ret = test_alarm(); 148 if (!strcmp(res->autotest, "interrupt_autotest")) 149 ret = test_interrupt(); 150 if (!strcmp(res->autotest, "cycles_autotest")) 151 ret = test_cycles(); 152 if (!strcmp(res->autotest, "ring_autotest")) 153 ret = test_ring(); 154 if (!strcmp(res->autotest, "ring_perf_autotest")) 155 ret = test_ring_perf(); 156 if (!strcmp(res->autotest, "timer_autotest")) 157 ret = test_timer(); 158 if (!strcmp(res->autotest, "timer_perf_autotest")) 159 ret = test_timer_perf(); 160 if (!strcmp(res->autotest, "mempool_autotest")) 161 ret = test_mempool(); 162 if (!strcmp(res->autotest, "mempool_perf_autotest")) 163 ret = test_mempool_perf(); 164 if (!strcmp(res->autotest, "memcpy_perf_autotest")) 165 ret = test_memcpy_perf(); 166 if (!strcmp(res->autotest, "func_reentrancy_autotest")) 167 ret = test_func_reentrancy(); 168 if (!strcmp(res->autotest, "red_autotest")) 169 ret = test_red(); 170 if (!strcmp(res->autotest, "sched_autotest")) 171 ret = test_sched(); 172 if (!strcmp(res->autotest, "meter_autotest")) 173 ret = test_meter(); 174 if (!strcmp(res->autotest, "kni_autotest")) 175 ret = test_kni(); 176 if (!strcmp(res->autotest, "power_autotest")) 177 ret = test_power(); 178 if (!strcmp(res->autotest, "common_autotest")) 179 ret = test_common(); 180 if (!strcmp(res->autotest, "ivshmem_autotest")) 181 ret = test_ivshmem(); 182 if (!strcmp(res->autotest, "devargs_autotest")) 183 ret = test_devargs(); 184 #ifdef RTE_LIBRTE_PMD_RING 185 if (!strcmp(res->autotest, "ring_pmd_autotest")) 186 ret = test_pmd_ring(); 187 #endif /* RTE_LIBRTE_PMD_RING */ 188 189 #ifdef RTE_LIBRTE_ACL 190 if (!strcmp(res->autotest, "acl_autotest")) 191 ret = test_acl(); 192 #endif /* RTE_LIBRTE_ACL */ 193 #ifdef RTE_LIBRTE_KVARGS 194 if (!strcmp(res->autotest, "kvargs_autotest")) 195 ret |= test_kvargs(); 196 #endif /* RTE_LIBRTE_KVARGS */ 197 198 if (ret == 0) 199 printf("Test OK\n"); 200 else 201 printf("Test Failed\n"); 202 fflush(stdout); 203 } 204 205 cmdline_parse_token_string_t cmd_autotest_autotest = 206 TOKEN_STRING_INITIALIZER(struct cmd_autotest_result, autotest, 207 "pci_autotest#memory_autotest#" 208 "per_lcore_autotest#spinlock_autotest#" 209 "rwlock_autotest#atomic_autotest#" 210 "byteorder_autotest#prefetch_autotest#" 211 "cycles_autotest#logs_autotest#" 212 "memzone_autotest#ring_autotest#" 213 "mempool_autotest#mbuf_autotest#" 214 "timer_autotest#malloc_autotest#" 215 "memcpy_autotest#hash_autotest#" 216 "lpm_autotest#debug_autotest#" 217 "lpm6_autotest#" 218 "errno_autotest#tailq_autotest#" 219 "string_autotest#multiprocess_autotest#" 220 "cpuflags_autotest#eal_flags_autotest#" 221 "alarm_autotest#interrupt_autotest#" 222 "version_autotest#eal_fs_autotest#" 223 "cmdline_autotest#func_reentrancy_autotest#" 224 "mempool_perf_autotest#hash_perf_autotest#" 225 "memcpy_perf_autotest#ring_perf_autotest#" 226 "red_autotest#meter_autotest#sched_autotest#" 227 "memcpy_perf_autotest#kni_autotest#" 228 "pm_autotest#ivshmem_autotest#" 229 "devargs_autotest#" 230 #ifdef RTE_LIBRTE_ACL 231 "acl_autotest#" 232 #endif 233 "power_autotest#" 234 "timer_perf_autotest#" 235 #ifdef RTE_LIBRTE_PMD_RING 236 "ring_pmd_autotest#" 237 #endif 238 #ifdef RTE_LIBRTE_KVARGS 239 "kvargs_autotest#" 240 #endif 241 "common_autotest"); 242 243 cmdline_parse_inst_t cmd_autotest = { 244 .f = cmd_autotest_parsed, /* function to call */ 245 .data = NULL, /* 2nd arg of func */ 246 .help_str = "launch autotest", 247 .tokens = { /* token list, NULL terminated */ 248 (void *)&cmd_autotest_autotest, 249 NULL, 250 }, 251 }; 252 253 /****************/ 254 255 struct cmd_dump_result { 256 cmdline_fixed_string_t dump; 257 }; 258 259 static void 260 dump_struct_sizes(void) 261 { 262 #define DUMP_SIZE(t) printf("sizeof(" #t ") = %u\n", (unsigned)sizeof(t)); 263 DUMP_SIZE(struct rte_mbuf); 264 DUMP_SIZE(struct rte_pktmbuf); 265 DUMP_SIZE(struct rte_ctrlmbuf); 266 DUMP_SIZE(struct rte_mempool); 267 DUMP_SIZE(struct rte_ring); 268 #undef DUMP_SIZE 269 } 270 271 static void cmd_dump_parsed(void *parsed_result, 272 __attribute__((unused)) struct cmdline *cl, 273 __attribute__((unused)) void *data) 274 { 275 struct cmd_dump_result *res = parsed_result; 276 277 if (!strcmp(res->dump, "dump_physmem")) 278 rte_dump_physmem_layout(stdout); 279 else if (!strcmp(res->dump, "dump_memzone")) 280 rte_memzone_dump(stdout); 281 else if (!strcmp(res->dump, "dump_log_history")) 282 rte_log_dump_history(stdout); 283 else if (!strcmp(res->dump, "dump_struct_sizes")) 284 dump_struct_sizes(); 285 else if (!strcmp(res->dump, "dump_ring")) 286 rte_ring_list_dump(stdout); 287 else if (!strcmp(res->dump, "dump_mempool")) 288 rte_mempool_list_dump(stdout); 289 else if (!strcmp(res->dump, "dump_devargs")) 290 rte_eal_devargs_dump(stdout); 291 } 292 293 cmdline_parse_token_string_t cmd_dump_dump = 294 TOKEN_STRING_INITIALIZER(struct cmd_dump_result, dump, 295 "dump_physmem#dump_memzone#dump_log_history#" 296 "dump_struct_sizes#dump_ring#dump_mempool#" 297 "dump_devargs"); 298 299 cmdline_parse_inst_t cmd_dump = { 300 .f = cmd_dump_parsed, /* function to call */ 301 .data = NULL, /* 2nd arg of func */ 302 .help_str = "dump status", 303 .tokens = { /* token list, NULL terminated */ 304 (void *)&cmd_dump_dump, 305 NULL, 306 }, 307 }; 308 309 /****************/ 310 311 struct cmd_dump_one_result { 312 cmdline_fixed_string_t dump; 313 cmdline_fixed_string_t name; 314 }; 315 316 static void cmd_dump_one_parsed(void *parsed_result, struct cmdline *cl, 317 __attribute__((unused)) void *data) 318 { 319 struct cmd_dump_one_result *res = parsed_result; 320 321 if (!strcmp(res->dump, "dump_ring")) { 322 struct rte_ring *r; 323 r = rte_ring_lookup(res->name); 324 if (r == NULL) { 325 cmdline_printf(cl, "Cannot find ring\n"); 326 return; 327 } 328 rte_ring_dump(stdout, r); 329 } 330 else if (!strcmp(res->dump, "dump_mempool")) { 331 struct rte_mempool *mp; 332 mp = rte_mempool_lookup(res->name); 333 if (mp == NULL) { 334 cmdline_printf(cl, "Cannot find mempool\n"); 335 return; 336 } 337 rte_mempool_dump(stdout, mp); 338 } 339 } 340 341 cmdline_parse_token_string_t cmd_dump_one_dump = 342 TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, dump, 343 "dump_ring#dump_mempool"); 344 345 cmdline_parse_token_string_t cmd_dump_one_name = 346 TOKEN_STRING_INITIALIZER(struct cmd_dump_one_result, name, NULL); 347 348 cmdline_parse_inst_t cmd_dump_one = { 349 .f = cmd_dump_one_parsed, /* function to call */ 350 .data = NULL, /* 2nd arg of func */ 351 .help_str = "dump one ring/mempool: dump_ring|dump_mempool <name>", 352 .tokens = { /* token list, NULL terminated */ 353 (void *)&cmd_dump_one_dump, 354 (void *)&cmd_dump_one_name, 355 NULL, 356 }, 357 }; 358 359 /****************/ 360 361 struct cmd_set_ring_result { 362 cmdline_fixed_string_t set; 363 cmdline_fixed_string_t name; 364 uint32_t value; 365 }; 366 367 static void cmd_set_ring_parsed(void *parsed_result, struct cmdline *cl, 368 __attribute__((unused)) void *data) 369 { 370 struct cmd_set_ring_result *res = parsed_result; 371 struct rte_ring *r; 372 int ret; 373 374 r = rte_ring_lookup(res->name); 375 if (r == NULL) { 376 cmdline_printf(cl, "Cannot find ring\n"); 377 return; 378 } 379 380 if (!strcmp(res->set, "set_watermark")) { 381 ret = rte_ring_set_water_mark(r, res->value); 382 if (ret != 0) 383 cmdline_printf(cl, "Cannot set water mark\n"); 384 } 385 } 386 387 cmdline_parse_token_string_t cmd_set_ring_set = 388 TOKEN_STRING_INITIALIZER(struct cmd_set_ring_result, set, 389 "set_watermark"); 390 391 cmdline_parse_token_string_t cmd_set_ring_name = 392 TOKEN_STRING_INITIALIZER(struct cmd_set_ring_result, name, NULL); 393 394 cmdline_parse_token_num_t cmd_set_ring_value = 395 TOKEN_NUM_INITIALIZER(struct cmd_set_ring_result, value, UINT32); 396 397 cmdline_parse_inst_t cmd_set_ring = { 398 .f = cmd_set_ring_parsed, /* function to call */ 399 .data = NULL, /* 2nd arg of func */ 400 .help_str = "set watermark: " 401 "set_watermark <ring_name> <value>", 402 .tokens = { /* token list, NULL terminated */ 403 (void *)&cmd_set_ring_set, 404 (void *)&cmd_set_ring_name, 405 (void *)&cmd_set_ring_value, 406 NULL, 407 }, 408 }; 409 410 /****************/ 411 412 struct cmd_quit_result { 413 cmdline_fixed_string_t quit; 414 }; 415 416 static void 417 cmd_quit_parsed(__attribute__((unused)) void *parsed_result, 418 struct cmdline *cl, 419 __attribute__((unused)) void *data) 420 { 421 cmdline_quit(cl); 422 } 423 424 cmdline_parse_token_string_t cmd_quit_quit = 425 TOKEN_STRING_INITIALIZER(struct cmd_quit_result, quit, 426 "quit"); 427 428 cmdline_parse_inst_t cmd_quit = { 429 .f = cmd_quit_parsed, /* function to call */ 430 .data = NULL, /* 2nd arg of func */ 431 .help_str = "exit application", 432 .tokens = { /* token list, NULL terminated */ 433 (void *)&cmd_quit_quit, 434 NULL, 435 }, 436 }; 437 438 /****************/ 439 440 cmdline_parse_ctx_t main_ctx[] = { 441 (cmdline_parse_inst_t *)&cmd_autotest, 442 (cmdline_parse_inst_t *)&cmd_dump, 443 (cmdline_parse_inst_t *)&cmd_dump_one, 444 (cmdline_parse_inst_t *)&cmd_set_ring, 445 (cmdline_parse_inst_t *)&cmd_quit, 446 NULL, 447 }; 448 449