1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2017 Intel Corporation 3 */ 4 5 #include <errno.h> 6 #include <getopt.h> 7 #include <stdarg.h> 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <signal.h> 11 #include <string.h> 12 #include <time.h> 13 #include <fcntl.h> 14 #include <sys/types.h> 15 16 #include <sys/queue.h> 17 #include <sys/stat.h> 18 19 #include <stdint.h> 20 #include <unistd.h> 21 #include <inttypes.h> 22 23 #include <rte_common.h> 24 #include <rte_byteorder.h> 25 #include <rte_log.h> 26 #include <rte_debug.h> 27 #include <rte_cycles.h> 28 #include <rte_memory.h> 29 #include <rte_launch.h> 30 #include <rte_eal.h> 31 #include <rte_per_lcore.h> 32 #include <rte_lcore.h> 33 #include <rte_branch_prediction.h> 34 #include <rte_mempool.h> 35 #include <rte_interrupts.h> 36 #include <rte_ether.h> 37 #include <rte_ethdev.h> 38 #include <rte_string_fns.h> 39 #include <rte_flow.h> 40 41 #include "testpmd.h" 42 43 enum { 44 #define TESTPMD_OPT_AUTO_START "auto-start" 45 TESTPMD_OPT_AUTO_START_NUM = 'a', 46 #define TESTPMD_OPT_HELP "help" 47 TESTPMD_OPT_HELP_NUM = 'h', 48 #define TESTPMD_OPT_INTERACTIVE "interactive" 49 TESTPMD_OPT_INTERACTIVE_NUM = 'i', 50 51 TESTPMD_OPT_LONG_MIN_NUM = 256, 52 #define TESTPMD_OPT_CMDLINE_FILE "cmdline-file" 53 TESTPMD_OPT_CMDLINE_FILE_NUM, 54 #define TESTPMD_OPT_ETH_PEERS_CONFIGFILE "eth-peers-configfile" 55 TESTPMD_OPT_ETH_PEERS_CONFIGFILE_NUM, 56 #define TESTPMD_OPT_ETH_PEER "eth-peer" 57 TESTPMD_OPT_ETH_PEER_NUM, 58 #define TESTPMD_OPT_TX_FIRST "tx-first" 59 TESTPMD_OPT_TX_FIRST_NUM, 60 #define TESTPMD_OPT_STATS_PERIOD "stats-period" 61 TESTPMD_OPT_STATS_PERIOD_NUM, 62 #define TESTPMD_OPT_DISPLAY_XSTATS "display-xstats" 63 TESTPMD_OPT_DISPLAY_XSTATS_NUM, 64 #define TESTPMD_OPT_NB_CORES "nb-cores" 65 TESTPMD_OPT_NB_CORES_NUM, 66 #define TESTPMD_OPT_NB_PORTS "nb-ports" 67 TESTPMD_OPT_NB_PORTS_NUM, 68 #define TESTPMD_OPT_COREMASK "coremask" 69 TESTPMD_OPT_COREMASK_NUM, 70 #define TESTPMD_OPT_PORTMASK "portmask" 71 TESTPMD_OPT_PORTMASK_NUM, 72 #define TESTPMD_OPT_PORTLIST "portlist" 73 TESTPMD_OPT_PORTLIST_NUM, 74 #define TESTPMD_OPT_NUMA "numa" 75 TESTPMD_OPT_NUMA_NUM, 76 #define TESTPMD_OPT_NO_NUMA "no-numa" 77 TESTPMD_OPT_NO_NUMA_NUM, 78 #define TESTPMD_OPT_MP_ANON "mp-anon" 79 TESTPMD_OPT_MP_ANON_NUM, 80 #define TESTPMD_OPT_PORT_NUMA_CONFIG "port-numa-config" 81 TESTPMD_OPT_PORT_NUMA_CONFIG_NUM, 82 #define TESTPMD_OPT_RING_NUMA_CONFIG "ring-numa-config" 83 TESTPMD_OPT_RING_NUMA_CONFIG_NUM, 84 #define TESTPMD_OPT_SOCKET_NUM "socket-num" 85 TESTPMD_OPT_SOCKET_NUM_NUM, 86 #define TESTPMD_OPT_MBUF_SIZE "mbuf-size" 87 TESTPMD_OPT_MBUF_SIZE_NUM, 88 #define TESTPMD_OPT_TOTAL_NUM_MBUFS "total-num-mbufs" 89 TESTPMD_OPT_TOTAL_NUM_MBUFS_NUM, 90 #define TESTPMD_OPT_MAX_PKT_LEN "max-pkt-len" 91 TESTPMD_OPT_MAX_PKT_LEN_NUM, 92 #define TESTPMD_OPT_MAX_LRO_PKT_SIZE "max-lro-pkt-size" 93 TESTPMD_OPT_MAX_LRO_PKT_SIZE_NUM, 94 #define TESTPMD_OPT_LATENCYSTATS "latencystats" 95 TESTPMD_OPT_LATENCYSTATS_NUM, 96 #define TESTPMD_OPT_BITRATE_STATS "bitrate-stats" 97 TESTPMD_OPT_BITRATE_STATS_NUM, 98 #define TESTPMD_OPT_DISABLE_CRC_STRIP "disable-crc-strip" 99 TESTPMD_OPT_DISABLE_CRC_STRIP_NUM, 100 #define TESTPMD_OPT_ENABLE_LRO "enable-lro" 101 TESTPMD_OPT_ENABLE_LRO_NUM, 102 #define TESTPMD_OPT_ENABLE_RX_CKSUM "enable-rx-cksum" 103 TESTPMD_OPT_ENABLE_RX_CKSUM_NUM, 104 #define TESTPMD_OPT_ENABLE_RX_TIMESTAMP "enable-rx-timestamp" 105 TESTPMD_OPT_ENABLE_RX_TIMESTAMP_NUM, 106 #define TESTPMD_OPT_ENABLE_SCATTER "enable-scatter" 107 TESTPMD_OPT_ENABLE_SCATTER_NUM, 108 #define TESTPMD_OPT_ENABLE_HW_VLAN "enable-hw-vlan" 109 TESTPMD_OPT_ENABLE_HW_VLAN_NUM, 110 #define TESTPMD_OPT_ENABLE_HW_VLAN_FILTER "enable-hw-vlan-filter" 111 TESTPMD_OPT_ENABLE_HW_VLAN_FILTER_NUM, 112 #define TESTPMD_OPT_ENABLE_HW_VLAN_STRIP "enable-hw-vlan-strip" 113 TESTPMD_OPT_ENABLE_HW_VLAN_STRIP_NUM, 114 #define TESTPMD_OPT_ENABLE_HW_VLAN_EXTEND "enable-hw-vlan-extend" 115 TESTPMD_OPT_ENABLE_HW_VLAN_EXTEND_NUM, 116 #define TESTPMD_OPT_ENABLE_HW_QINQ_STRIP "enable-hw-qinq-strip" 117 TESTPMD_OPT_ENABLE_HW_QINQ_STRIP_NUM, 118 #define TESTPMD_OPT_ENABLE_DROP_EN "enable-drop-en" 119 TESTPMD_OPT_ENABLE_DROP_EN_NUM, 120 #define TESTPMD_OPT_DISABLE_RSS "disable-rss" 121 TESTPMD_OPT_DISABLE_RSS_NUM, 122 #define TESTPMD_OPT_PORT_TOPOLOGY "port-topology" 123 TESTPMD_OPT_PORT_TOPOLOGY_NUM, 124 #define TESTPMD_OPT_FORWARD_MODE "forward-mode" 125 TESTPMD_OPT_FORWARD_MODE_NUM, 126 #define TESTPMD_OPT_RSS_IP "rss-ip" 127 TESTPMD_OPT_RSS_IP_NUM, 128 #define TESTPMD_OPT_RSS_UDP "rss-udp" 129 TESTPMD_OPT_RSS_UDP_NUM, 130 #define TESTPMD_OPT_RSS_LEVEL_OUTER "rss-level-outer" 131 TESTPMD_OPT_RSS_LEVEL_OUTER_NUM, 132 #define TESTPMD_OPT_RSS_LEVEL_INNER "rss-level-inner" 133 TESTPMD_OPT_RSS_LEVEL_INNER_NUM, 134 #define TESTPMD_OPT_RXQ "rxq" 135 TESTPMD_OPT_RXQ_NUM, 136 #define TESTPMD_OPT_TXQ "txq" 137 TESTPMD_OPT_TXQ_NUM, 138 #define TESTPMD_OPT_RXD "rxd" 139 TESTPMD_OPT_RXD_NUM, 140 #define TESTPMD_OPT_TXD "txd" 141 TESTPMD_OPT_TXD_NUM, 142 #define TESTPMD_OPT_HAIRPINQ "hairpinq" 143 TESTPMD_OPT_HAIRPINQ_NUM, 144 #define TESTPMD_OPT_HAIRPIN_MODE "hairpin-mode" 145 TESTPMD_OPT_HAIRPIN_MODE_NUM, 146 #define TESTPMD_OPT_BURST "burst" 147 TESTPMD_OPT_BURST_NUM, 148 #define TESTPMD_OPT_FLOWGEN_CLONES "flowgen-clones" 149 TESTPMD_OPT_FLOWGEN_CLONES_NUM, 150 #define TESTPMD_OPT_FLOWGEN_FLOWS "flowgen-flows" 151 TESTPMD_OPT_FLOWGEN_FLOWS_NUM, 152 #define TESTPMD_OPT_MBCACHE "mbcache" 153 TESTPMD_OPT_MBCACHE_NUM, 154 #define TESTPMD_OPT_TXPT "txpt" 155 TESTPMD_OPT_TXPT_NUM, 156 #define TESTPMD_OPT_TXHT "txht" 157 TESTPMD_OPT_TXHT_NUM, 158 #define TESTPMD_OPT_TXWT "txwt" 159 TESTPMD_OPT_TXWT_NUM, 160 #define TESTPMD_OPT_TXFREET "txfreet" 161 TESTPMD_OPT_TXFREET_NUM, 162 #define TESTPMD_OPT_TXRST "txrst" 163 TESTPMD_OPT_TXRST_NUM, 164 #define TESTPMD_OPT_RXPT "rxpt" 165 TESTPMD_OPT_RXPT_NUM, 166 #define TESTPMD_OPT_RXHT "rxht" 167 TESTPMD_OPT_RXHT_NUM, 168 #define TESTPMD_OPT_RXWT "rxwt" 169 TESTPMD_OPT_RXWT_NUM, 170 #define TESTPMD_OPT_RXFREET "rxfreet" 171 TESTPMD_OPT_RXFREET_NUM, 172 #define TESTPMD_OPT_NO_FLUSH_RX "no-flush-rx" 173 TESTPMD_OPT_NO_FLUSH_RX_NUM, 174 #define TESTPMD_OPT_FLOW_ISOLATE_ALL "flow-isolate-all" 175 TESTPMD_OPT_FLOW_ISOLATE_ALL_NUM, 176 #define TESTPMD_OPT_DISABLE_FLOW_FLUSH "disable-flow-flush" 177 TESTPMD_OPT_DISABLE_FLOW_FLUSH_NUM, 178 #define TESTPMD_OPT_RXOFFS "rxoffs" 179 TESTPMD_OPT_RXOFFS_NUM, 180 #define TESTPMD_OPT_RXPKTS "rxpkts" 181 TESTPMD_OPT_RXPKTS_NUM, 182 #define TESTPMD_OPT_RXHDRS "rxhdrs" 183 TESTPMD_OPT_RXHDRS_NUM, 184 #define TESTPMD_OPT_TXPKTS "txpkts" 185 TESTPMD_OPT_TXPKTS_NUM, 186 #define TESTPMD_OPT_MULTI_RX_MEMPOOL "multi-rx-mempool" 187 TESTPMD_OPT_MULTI_RX_MEMPOOL_NUM, 188 #define TESTPMD_OPT_TXONLY_MULTI_FLOW "txonly-multi-flow" 189 TESTPMD_OPT_TXONLY_MULTI_FLOW_NUM, 190 #define TESTPMD_OPT_RXQ_SHARE "rxq-share" 191 TESTPMD_OPT_RXQ_SHARE_NUM, 192 #define TESTPMD_OPT_ETH_LINK_SPEED "eth-link-speed" 193 TESTPMD_OPT_ETH_LINK_SPEED_NUM, 194 #define TESTPMD_OPT_DISABLE_LINK_CHECK "disable-link-check" 195 TESTPMD_OPT_DISABLE_LINK_CHECK_NUM, 196 #define TESTPMD_OPT_DISABLE_DEVICE_START "disable-device-start" 197 TESTPMD_OPT_DISABLE_DEVICE_START_NUM, 198 #define TESTPMD_OPT_NO_LSC_INTERRUPT "no-lsc-interrupt" 199 TESTPMD_OPT_NO_LSC_INTERRUPT_NUM, 200 #define TESTPMD_OPT_NO_RMV_INTERRUPT "no-rmv-interrupt" 201 TESTPMD_OPT_NO_RMV_INTERRUPT_NUM, 202 #define TESTPMD_OPT_PRINT_EVENT "print-event" 203 TESTPMD_OPT_PRINT_EVENT_NUM, 204 #define TESTPMD_OPT_MASK_EVENT "mask-event" 205 TESTPMD_OPT_MASK_EVENT_NUM, 206 #define TESTPMD_OPT_TX_OFFLOADS "tx-offloads" 207 TESTPMD_OPT_TX_OFFLOADS_NUM, 208 #define TESTPMD_OPT_RX_OFFLOADS "rx-offloads" 209 TESTPMD_OPT_RX_OFFLOADS_NUM, 210 #define TESTPMD_OPT_HOT_PLUG "hot-plug" 211 TESTPMD_OPT_HOT_PLUG_NUM, 212 #define TESTPMD_OPT_VXLAN_GPE_PORT "vxlan-gpe-port" 213 TESTPMD_OPT_VXLAN_GPE_PORT_NUM, 214 #define TESTPMD_OPT_GENEVE_PARSED_PORT "geneve-parsed-port" 215 TESTPMD_OPT_GENEVE_PARSED_PORT_NUM, 216 #define TESTPMD_OPT_MLOCKALL "mlockall" 217 TESTPMD_OPT_MLOCKALL_NUM, 218 #define TESTPMD_OPT_NO_MLOCKALL "no-mlockall" 219 TESTPMD_OPT_NO_MLOCKALL_NUM, 220 #define TESTPMD_OPT_MP_ALLOC "mp-alloc" 221 TESTPMD_OPT_MP_ALLOC_NUM, 222 #define TESTPMD_OPT_TX_IP "tx-ip" 223 TESTPMD_OPT_TX_IP_NUM, 224 #define TESTPMD_OPT_TX_UDP "tx-udp" 225 TESTPMD_OPT_TX_UDP_NUM, 226 #define TESTPMD_OPT_NOISY_TX_SW_BUFFER_SIZE "noisy-tx-sw-buffer-size" 227 TESTPMD_OPT_NOISY_TX_SW_BUFFER_SIZE_NUM, 228 #define TESTPMD_OPT_NOISY_TX_SW_BUFFER_FLUSHTIME "noisy-tx-sw-buffer-flushtime" 229 TESTPMD_OPT_NOISY_TX_SW_BUFFER_FLUSHTIME_NUM, 230 #define TESTPMD_OPT_NOISY_LKUP_MEMORY "noisy-lkup-memory" 231 TESTPMD_OPT_NOISY_LKUP_MEMORY_NUM, 232 #define TESTPMD_OPT_NOISY_LKUP_NUM_WRITES "noisy-lkup-num-writes" 233 TESTPMD_OPT_NOISY_LKUP_NUM_WRITES_NUM, 234 #define TESTPMD_OPT_NOISY_LKUP_NUM_READS "noisy-lkup-num-reads" 235 TESTPMD_OPT_NOISY_LKUP_NUM_READS_NUM, 236 #define TESTPMD_OPT_NOISY_LKUP_NUM_READS_WRITES "noisy-lkup-num-reads-writes" 237 TESTPMD_OPT_NOISY_LKUP_NUM_READS_WRITES_NUM, 238 #define TESTPMD_OPT_NOISY_FORWARD_MODE "noisy-forward-mode" 239 TESTPMD_OPT_NOISY_FORWARD_MODE_NUM, 240 #define TESTPMD_OPT_NO_IOVA_CONTIG "no-iova-contig" 241 TESTPMD_OPT_NO_IOVA_CONTIG_NUM, 242 #define TESTPMD_OPT_RX_MQ_MODE "rx-mq-mode" 243 TESTPMD_OPT_RX_MQ_MODE_NUM, 244 #define TESTPMD_OPT_RECORD_CORE_CYCLES "record-core-cycles" 245 TESTPMD_OPT_RECORD_CORE_CYCLES_NUM, 246 #define TESTPMD_OPT_RECORD_BURST_STATS "record-burst-stats" 247 TESTPMD_OPT_RECORD_BURST_STATS_NUM, 248 #define TESTPMD_OPT_NUM_PROCS "num-procs" 249 TESTPMD_OPT_NUM_PROCS_NUM, 250 #define TESTPMD_OPT_PROC_ID "proc-id" 251 TESTPMD_OPT_PROC_ID_NUM, 252 253 TESTPMD_OPT_LONG_MAX_NUM 254 }; 255 256 static const char short_options[] = { 257 "a" /* auto-start */ 258 "h" /* help */ 259 "i" /* interactive */ 260 }; 261 262 #define NO_ARG(opt) { opt, no_argument, NULL, opt ## _NUM } 263 #define REQUIRED_ARG(opt) { opt, required_argument, NULL, opt ## _NUM } 264 #define OPTIONAL_ARG(opt) { opt, optional_argument, NULL, opt ## _NUM } 265 static const struct option long_options[] = { 266 NO_ARG(TESTPMD_OPT_AUTO_START), 267 NO_ARG(TESTPMD_OPT_HELP), 268 NO_ARG(TESTPMD_OPT_INTERACTIVE), 269 REQUIRED_ARG(TESTPMD_OPT_CMDLINE_FILE), 270 REQUIRED_ARG(TESTPMD_OPT_ETH_PEERS_CONFIGFILE), 271 REQUIRED_ARG(TESTPMD_OPT_ETH_PEER), 272 NO_ARG(TESTPMD_OPT_TX_FIRST), 273 REQUIRED_ARG(TESTPMD_OPT_STATS_PERIOD), 274 REQUIRED_ARG(TESTPMD_OPT_DISPLAY_XSTATS), 275 REQUIRED_ARG(TESTPMD_OPT_NB_CORES), 276 REQUIRED_ARG(TESTPMD_OPT_NB_PORTS), 277 REQUIRED_ARG(TESTPMD_OPT_COREMASK), 278 REQUIRED_ARG(TESTPMD_OPT_PORTMASK), 279 REQUIRED_ARG(TESTPMD_OPT_PORTLIST), 280 NO_ARG(TESTPMD_OPT_NUMA), 281 NO_ARG(TESTPMD_OPT_NO_NUMA), 282 NO_ARG(TESTPMD_OPT_MP_ANON), /* deprecated */ 283 REQUIRED_ARG(TESTPMD_OPT_PORT_NUMA_CONFIG), 284 REQUIRED_ARG(TESTPMD_OPT_RING_NUMA_CONFIG), 285 REQUIRED_ARG(TESTPMD_OPT_SOCKET_NUM), 286 REQUIRED_ARG(TESTPMD_OPT_MBUF_SIZE), 287 REQUIRED_ARG(TESTPMD_OPT_TOTAL_NUM_MBUFS), 288 REQUIRED_ARG(TESTPMD_OPT_MAX_PKT_LEN), 289 REQUIRED_ARG(TESTPMD_OPT_MAX_LRO_PKT_SIZE), 290 #ifdef RTE_LIB_LATENCYSTATS 291 REQUIRED_ARG(TESTPMD_OPT_LATENCYSTATS), 292 #endif 293 #ifdef RTE_LIB_BITRATESTATS 294 REQUIRED_ARG(TESTPMD_OPT_BITRATE_STATS), 295 #endif 296 NO_ARG(TESTPMD_OPT_DISABLE_CRC_STRIP), 297 NO_ARG(TESTPMD_OPT_ENABLE_LRO), 298 NO_ARG(TESTPMD_OPT_ENABLE_RX_CKSUM), 299 NO_ARG(TESTPMD_OPT_ENABLE_RX_TIMESTAMP), 300 NO_ARG(TESTPMD_OPT_ENABLE_SCATTER), 301 NO_ARG(TESTPMD_OPT_ENABLE_HW_VLAN), 302 NO_ARG(TESTPMD_OPT_ENABLE_HW_VLAN_FILTER), 303 NO_ARG(TESTPMD_OPT_ENABLE_HW_VLAN_STRIP), 304 NO_ARG(TESTPMD_OPT_ENABLE_HW_VLAN_EXTEND), 305 NO_ARG(TESTPMD_OPT_ENABLE_HW_QINQ_STRIP), 306 NO_ARG(TESTPMD_OPT_ENABLE_DROP_EN), 307 NO_ARG(TESTPMD_OPT_DISABLE_RSS), 308 REQUIRED_ARG(TESTPMD_OPT_PORT_TOPOLOGY), 309 REQUIRED_ARG(TESTPMD_OPT_FORWARD_MODE), 310 NO_ARG(TESTPMD_OPT_RSS_IP), 311 NO_ARG(TESTPMD_OPT_RSS_UDP), 312 NO_ARG(TESTPMD_OPT_RSS_LEVEL_OUTER), 313 NO_ARG(TESTPMD_OPT_RSS_LEVEL_INNER), 314 REQUIRED_ARG(TESTPMD_OPT_RXQ), 315 REQUIRED_ARG(TESTPMD_OPT_TXQ), 316 REQUIRED_ARG(TESTPMD_OPT_RXD), 317 REQUIRED_ARG(TESTPMD_OPT_TXD), 318 REQUIRED_ARG(TESTPMD_OPT_HAIRPINQ), 319 REQUIRED_ARG(TESTPMD_OPT_HAIRPIN_MODE), 320 REQUIRED_ARG(TESTPMD_OPT_BURST), 321 REQUIRED_ARG(TESTPMD_OPT_FLOWGEN_CLONES), 322 REQUIRED_ARG(TESTPMD_OPT_FLOWGEN_FLOWS), 323 REQUIRED_ARG(TESTPMD_OPT_MBCACHE), 324 REQUIRED_ARG(TESTPMD_OPT_TXPT), 325 REQUIRED_ARG(TESTPMD_OPT_TXHT), 326 REQUIRED_ARG(TESTPMD_OPT_TXWT), 327 REQUIRED_ARG(TESTPMD_OPT_TXFREET), 328 REQUIRED_ARG(TESTPMD_OPT_TXRST), 329 REQUIRED_ARG(TESTPMD_OPT_RXPT), 330 REQUIRED_ARG(TESTPMD_OPT_RXHT), 331 REQUIRED_ARG(TESTPMD_OPT_RXWT), 332 REQUIRED_ARG(TESTPMD_OPT_RXFREET), 333 NO_ARG(TESTPMD_OPT_NO_FLUSH_RX), 334 NO_ARG(TESTPMD_OPT_FLOW_ISOLATE_ALL), 335 NO_ARG(TESTPMD_OPT_DISABLE_FLOW_FLUSH), 336 REQUIRED_ARG(TESTPMD_OPT_RXOFFS), 337 REQUIRED_ARG(TESTPMD_OPT_RXPKTS), 338 REQUIRED_ARG(TESTPMD_OPT_RXHDRS), 339 REQUIRED_ARG(TESTPMD_OPT_TXPKTS), 340 NO_ARG(TESTPMD_OPT_MULTI_RX_MEMPOOL), 341 NO_ARG(TESTPMD_OPT_TXONLY_MULTI_FLOW), 342 OPTIONAL_ARG(TESTPMD_OPT_RXQ_SHARE), 343 REQUIRED_ARG(TESTPMD_OPT_ETH_LINK_SPEED), 344 NO_ARG(TESTPMD_OPT_DISABLE_LINK_CHECK), 345 NO_ARG(TESTPMD_OPT_DISABLE_DEVICE_START), 346 NO_ARG(TESTPMD_OPT_NO_LSC_INTERRUPT), 347 NO_ARG(TESTPMD_OPT_NO_RMV_INTERRUPT), 348 REQUIRED_ARG(TESTPMD_OPT_PRINT_EVENT), 349 REQUIRED_ARG(TESTPMD_OPT_MASK_EVENT), 350 REQUIRED_ARG(TESTPMD_OPT_TX_OFFLOADS), 351 REQUIRED_ARG(TESTPMD_OPT_RX_OFFLOADS), 352 NO_ARG(TESTPMD_OPT_HOT_PLUG), 353 REQUIRED_ARG(TESTPMD_OPT_VXLAN_GPE_PORT), 354 REQUIRED_ARG(TESTPMD_OPT_GENEVE_PARSED_PORT), 355 #ifndef RTE_EXEC_ENV_WINDOWS 356 NO_ARG(TESTPMD_OPT_MLOCKALL), 357 NO_ARG(TESTPMD_OPT_NO_MLOCKALL), 358 #endif 359 REQUIRED_ARG(TESTPMD_OPT_MP_ALLOC), 360 REQUIRED_ARG(TESTPMD_OPT_TX_IP), 361 REQUIRED_ARG(TESTPMD_OPT_TX_UDP), 362 REQUIRED_ARG(TESTPMD_OPT_NOISY_TX_SW_BUFFER_SIZE), 363 REQUIRED_ARG(TESTPMD_OPT_NOISY_TX_SW_BUFFER_FLUSHTIME), 364 REQUIRED_ARG(TESTPMD_OPT_NOISY_LKUP_MEMORY), 365 REQUIRED_ARG(TESTPMD_OPT_NOISY_LKUP_NUM_WRITES), 366 REQUIRED_ARG(TESTPMD_OPT_NOISY_LKUP_NUM_READS), 367 REQUIRED_ARG(TESTPMD_OPT_NOISY_LKUP_NUM_READS_WRITES), 368 REQUIRED_ARG(TESTPMD_OPT_NOISY_FORWARD_MODE), 369 NO_ARG(TESTPMD_OPT_NO_IOVA_CONTIG), 370 REQUIRED_ARG(TESTPMD_OPT_RX_MQ_MODE), 371 NO_ARG(TESTPMD_OPT_RECORD_CORE_CYCLES), 372 NO_ARG(TESTPMD_OPT_RECORD_BURST_STATS), 373 REQUIRED_ARG(TESTPMD_OPT_NUM_PROCS), 374 REQUIRED_ARG(TESTPMD_OPT_PROC_ID), 375 { 0, 0, NULL, 0 } 376 }; 377 #undef NO_ARG 378 #undef REQUIRED_ARG 379 #undef OPTIONAL_ARG 380 381 static void 382 usage(char* progname) 383 { 384 printf("\nUsage: %s [EAL options] -- [testpmd options]\n\n", 385 progname); 386 printf(" --interactive: run in interactive mode.\n"); 387 printf(" --cmdline-file: execute cli commands before startup.\n"); 388 printf(" --auto-start: start forwarding on init " 389 "[always when non-interactive].\n"); 390 printf(" --help: display this message and quit.\n"); 391 printf(" --tx-first: start forwarding sending a burst first " 392 "(only if interactive is disabled).\n"); 393 printf(" --stats-period=PERIOD: statistics will be shown " 394 "every PERIOD seconds (only if interactive is disabled).\n"); 395 printf(" --display-xstats xstat_name1[,...]: comma-separated list of " 396 "extended statistics to show. Used with --stats-period " 397 "specified or interactive commands that show Rx/Tx statistics " 398 "(i.e. 'show port stats').\n"); 399 printf(" --num-procs=N: set the total number of multi-process instances.\n"); 400 printf(" --proc-id=id: set the id of the current process from " 401 "multi-process instances (0 <= id < num-procs).\n"); 402 printf(" --nb-cores=N: set the number of forwarding cores " 403 "(1 <= N <= %d).\n", nb_lcores); 404 printf(" --nb-ports=N: set the number of forwarding ports " 405 "(1 <= N <= %d).\n", nb_ports); 406 printf(" --coremask=COREMASK: hexadecimal bitmask of cores running " 407 "the packet forwarding test. The main lcore is reserved for " 408 "command line parsing only, and cannot be masked on for " 409 "packet forwarding.\n"); 410 printf(" --portmask=PORTMASK: hexadecimal bitmask of ports used " 411 "by the packet forwarding test.\n"); 412 printf(" --portlist=PORTLIST: list of forwarding ports\n"); 413 printf(" --numa: enable NUMA-aware allocation of RX/TX rings and of " 414 "RX memory buffers (mbufs).\n"); 415 printf(" --no-numa: disable NUMA-aware allocation.\n"); 416 printf(" --port-numa-config=(port,socket)[,(port,socket)]: " 417 "specify the socket on which the memory pool " 418 "used by the port will be allocated.\n"); 419 printf(" --ring-numa-config=(port,flag,socket)[,(port,flag,socket)]: " 420 "specify the socket on which the TX/RX rings for " 421 "the port will be allocated " 422 "(flag: 1 for RX; 2 for TX; 3 for RX and TX).\n"); 423 printf(" --socket-num=N: set socket from which all memory is allocated " 424 "in NUMA mode.\n"); 425 printf(" --mbuf-size=N,[N1[,..Nn]: set the data size of mbuf to " 426 "N bytes. If multiple numbers are specified the extra pools " 427 "will be created to receive packets based on the features " 428 "supported, like packet split, multi-rx-mempool.\n"); 429 printf(" --total-num-mbufs=N: set the number of mbufs to be allocated " 430 "in mbuf pools.\n"); 431 printf(" --max-pkt-len=N: set the maximum size of packet to N bytes.\n"); 432 printf(" --max-lro-pkt-size=N: set the maximum LRO aggregated packet " 433 "size to N bytes.\n"); 434 printf(" --eth-peers-configfile=name: config file with ethernet addresses " 435 "of peer ports.\n"); 436 printf(" --eth-peer=X,M:M:M:M:M:M: set the MAC address of the X peer " 437 "port (0 <= X < %d).\n", RTE_MAX_ETHPORTS); 438 printf(" --disable-crc-strip: disable CRC stripping by hardware.\n"); 439 printf(" --enable-scatter: enable scattered Rx.\n"); 440 printf(" --enable-lro: enable large receive offload.\n"); 441 printf(" --enable-rx-cksum: enable rx hardware checksum offload.\n"); 442 printf(" --enable-rx-timestamp: enable rx hardware timestamp offload.\n"); 443 printf(" --enable-hw-vlan: enable hardware vlan.\n"); 444 printf(" --enable-hw-vlan-filter: enable hardware vlan filter.\n"); 445 printf(" --enable-hw-vlan-strip: enable hardware vlan strip.\n"); 446 printf(" --enable-hw-vlan-extend: enable hardware vlan extend.\n"); 447 printf(" --enable-hw-qinq-strip: enable hardware qinq strip.\n"); 448 printf(" --enable-drop-en: enable per queue packet drop.\n"); 449 printf(" --disable-rss: disable rss.\n"); 450 printf(" --port-topology=<paired|chained|loop>: set port topology (paired " 451 "is default).\n"); 452 printf(" --forward-mode=N: set forwarding mode (N: %s).\n", 453 list_pkt_forwarding_modes()); 454 printf(" --forward-mode=5tswap: set forwarding mode to " 455 "swap L2,L3,L4 for MAC, IPv4/IPv6 and TCP/UDP only.\n"); 456 printf(" --rss-ip: set RSS functions to IPv4/IPv6 only .\n"); 457 printf(" --rss-udp: set RSS functions to IPv4/IPv6 + UDP.\n"); 458 printf(" --rss-level-inner: set RSS hash level to innermost\n"); 459 printf(" --rss-level-outer: set RSS hash level to outermost\n"); 460 printf(" --rxq=N: set the number of RX queues per port to N.\n"); 461 printf(" --rxd=N: set the number of descriptors in RX rings to N.\n"); 462 printf(" --txq=N: set the number of TX queues per port to N.\n"); 463 printf(" --txd=N: set the number of descriptors in TX rings to N.\n"); 464 printf(" --hairpinq=N: set the number of hairpin queues per port to " 465 "N.\n"); 466 printf(" --burst=N: set the number of packets per burst to N.\n"); 467 printf(" --flowgen-clones=N: set the number of single packet clones to send in flowgen mode. Should be less than burst value.\n"); 468 printf(" --flowgen-flows=N: set the number of flows in flowgen mode to N (1 <= N <= INT32_MAX).\n"); 469 printf(" --mbcache=N: set the cache of mbuf memory pool to N.\n"); 470 printf(" --rxpt=N: set prefetch threshold register of RX rings to N.\n"); 471 printf(" --rxht=N: set the host threshold register of RX rings to N.\n"); 472 printf(" --rxfreet=N: set the free threshold of RX descriptors to N " 473 "(0 <= N < value of rxd).\n"); 474 printf(" --rxwt=N: set the write-back threshold register of RX rings to N.\n"); 475 printf(" --txpt=N: set the prefetch threshold register of TX rings to N.\n"); 476 printf(" --txht=N: set the nhost threshold register of TX rings to N.\n"); 477 printf(" --txwt=N: set the write-back threshold register of TX rings to N.\n"); 478 printf(" --txfreet=N: set the transmit free threshold of TX rings to N " 479 "(0 <= N <= value of txd).\n"); 480 printf(" --txrst=N: set the transmit RS bit threshold of TX rings to N " 481 "(0 <= N <= value of txd).\n"); 482 printf(" --no-flush-rx: Don't flush RX streams before forwarding." 483 " Used mainly with PCAP drivers.\n"); 484 printf(" --rxoffs=X[,Y]*: set RX segment offsets for split.\n"); 485 printf(" --rxpkts=X[,Y]*: set RX segment sizes to split.\n"); 486 printf(" --rxhdrs=eth[,ipv4]*: set RX segment protocol to split.\n"); 487 printf(" --txpkts=X[,Y]*: set TX segment sizes" 488 " or total packet length.\n"); 489 printf(" --multi-rx-mempool: enable multi-rx-mempool support\n"); 490 printf(" --txonly-multi-flow: generate multiple flows in txonly mode\n"); 491 printf(" --tx-ip=src,dst: IP addresses in Tx-only mode\n"); 492 printf(" --tx-udp=src[,dst]: UDP ports in Tx-only mode\n"); 493 printf(" --eth-link-speed: force link speed.\n"); 494 printf(" --rxq-share=X: number of ports per shared Rx queue groups, defaults to UINT32_MAX (1 group)\n"); 495 printf(" --disable-link-check: disable check on link status when " 496 "starting/stopping ports.\n"); 497 printf(" --disable-device-start: do not automatically start port\n"); 498 printf(" --no-lsc-interrupt: disable link status change interrupt.\n"); 499 printf(" --no-rmv-interrupt: disable device removal interrupt.\n"); 500 #ifdef RTE_LIB_BITRATESTATS 501 printf(" --bitrate-stats=N: set the logical core N to perform " 502 "bit-rate calculation.\n"); 503 #endif 504 #ifdef RTE_LIB_LATENCYSTATS 505 printf(" --latencystats=N: enable latency and jitter statistics " 506 "monitoring on forwarding lcore id N.\n"); 507 #endif 508 printf(" --print-event <unknown|intr_lsc|queue_state|intr_reset|vf_mbox|macsec|intr_rmv|flow_aged|err_recovering|recovery_success|recovery_failed|all>: " 509 "enable print of designated event or all of them.\n"); 510 printf(" --mask-event <unknown|intr_lsc|queue_state|intr_reset|vf_mbox|macsec|intr_rmv|flow_aged|err_recovering|recovery_success|recovery_failed||all>: " 511 "disable print of designated event or all of them.\n"); 512 printf(" --flow-isolate-all: " 513 "requests flow API isolated mode on all ports at initialization time.\n"); 514 printf(" --disable-flow-flush: disable port flow flush when stop port.\n"); 515 printf(" --tx-offloads=0xXXXXXXXX: hexadecimal bitmask of TX queue offloads\n"); 516 printf(" --rx-offloads=0xXXXXXXXX: hexadecimal bitmask of RX queue offloads\n"); 517 printf(" --hot-plug: enable hot plug for device.\n"); 518 printf(" --vxlan-gpe-port=N: UPD port of tunnel VXLAN-GPE\n"); 519 printf(" --geneve-parsed-port=N: UPD port to parse GENEVE tunnel protocol\n"); 520 #ifndef RTE_EXEC_ENV_WINDOWS 521 printf(" --mlockall: lock all memory\n"); 522 printf(" --no-mlockall: do not lock all memory\n"); 523 #endif 524 printf(" --mp-alloc <native|anon|xmem|xmemhuge>: mempool allocation method.\n" 525 " native: use regular DPDK memory to create and populate mempool\n" 526 " anon: use regular DPDK memory to create and anonymous memory to populate mempool\n" 527 " xmem: use anonymous memory to create and populate mempool\n" 528 " xmemhuge: use anonymous hugepage memory to create and populate mempool\n"); 529 printf(" --noisy-forward-mode=<io|mac|macswap|5tswap>: set the sub-fwd mode, defaults to io\n"); 530 printf(" --noisy-tx-sw-buffer-size=N: size of FIFO buffer\n"); 531 printf(" --noisy-tx-sw-buffer-flushtime=N: flush FIFO after N ms\n"); 532 printf(" --noisy-lkup-memory=N: allocate N MB of VNF memory\n"); 533 printf(" --noisy-lkup-num-writes=N: do N random writes per packet\n"); 534 printf(" --noisy-lkup-num-reads=N: do N random reads per packet\n"); 535 printf(" --noisy-lkup-num-reads-writes=N: do N random reads and writes per packet\n"); 536 printf(" --no-iova-contig: mempool memory can be IOVA non contiguous. " 537 "valid only with --mp-alloc=anon\n"); 538 printf(" --rx-mq-mode=0xX: hexadecimal bitmask of RX mq mode can be " 539 "enabled\n"); 540 printf(" --record-core-cycles: enable measurement of CPU cycles.\n"); 541 printf(" --record-burst-stats: enable display of RX and TX bursts.\n"); 542 printf(" --hairpin-mode=0xXX: bitmask set the hairpin port mode.\n" 543 " 0x10 - explicit Tx rule, 0x02 - hairpin ports paired\n" 544 " 0x01 - hairpin ports loop, 0x00 - hairpin port self\n"); 545 } 546 547 static int 548 init_peer_eth_addrs(const char *config_filename) 549 { 550 FILE *config_file; 551 portid_t i; 552 char buf[50]; 553 554 config_file = fopen(config_filename, "r"); 555 if (config_file == NULL) { 556 perror("Failed to open eth config file\n"); 557 return -1; 558 } 559 560 for (i = 0; i < RTE_MAX_ETHPORTS; i++) { 561 562 if (fgets(buf, sizeof(buf), config_file) == NULL) 563 break; 564 565 if (rte_ether_unformat_addr(buf, &peer_eth_addrs[i]) < 0) { 566 fprintf(stderr, "Bad MAC address format on line %d\n", 567 i + 1); 568 fclose(config_file); 569 return -1; 570 } 571 } 572 fclose(config_file); 573 nb_peer_eth_addrs = (portid_t) i; 574 return 0; 575 } 576 577 /* 578 * Parse the coremask given as argument (hexadecimal string) and set 579 * the global configuration of forwarding cores. 580 */ 581 static void 582 parse_fwd_coremask(const char *coremask) 583 { 584 char *end; 585 unsigned long long int cm; 586 587 /* parse hexadecimal string */ 588 end = NULL; 589 cm = strtoull(coremask, &end, 16); 590 if ((coremask[0] == '\0') || (end == NULL) || (*end != '\0')) 591 rte_exit(EXIT_FAILURE, "Invalid fwd core mask\n"); 592 else if (set_fwd_lcores_mask((uint64_t) cm) < 0) 593 rte_exit(EXIT_FAILURE, "coremask is not valid\n"); 594 } 595 596 /* 597 * Parse the coremask given as argument (hexadecimal string) and set 598 * the global configuration of forwarding cores. 599 */ 600 static void 601 parse_fwd_portmask(const char *portmask) 602 { 603 char *end; 604 unsigned long long int pm; 605 606 /* parse hexadecimal string */ 607 end = NULL; 608 pm = strtoull(portmask, &end, 16); 609 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0')) 610 rte_exit(EXIT_FAILURE, "Invalid fwd port mask\n"); 611 else 612 set_fwd_ports_mask((uint64_t) pm); 613 } 614 615 static void 616 print_invalid_socket_id_error(void) 617 { 618 unsigned int i = 0; 619 620 fprintf(stderr, "Invalid socket id, options are: "); 621 for (i = 0; i < num_sockets; i++) { 622 fprintf(stderr, "%u%s", socket_ids[i], 623 (i == num_sockets - 1) ? "\n" : ","); 624 } 625 } 626 627 static int 628 parse_portnuma_config(const char *q_arg) 629 { 630 char s[256]; 631 const char *p, *p0 = q_arg; 632 char *end; 633 uint8_t i, socket_id; 634 portid_t port_id; 635 unsigned size; 636 enum fieldnames { 637 FLD_PORT = 0, 638 FLD_SOCKET, 639 _NUM_FLD 640 }; 641 unsigned long int_fld[_NUM_FLD]; 642 char *str_fld[_NUM_FLD]; 643 644 /* reset from value set at definition */ 645 while ((p = strchr(p0,'(')) != NULL) { 646 ++p; 647 if((p0 = strchr(p,')')) == NULL) 648 return -1; 649 650 size = p0 - p; 651 if(size >= sizeof(s)) 652 return -1; 653 654 snprintf(s, sizeof(s), "%.*s", size, p); 655 if (rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ',') != _NUM_FLD) 656 return -1; 657 for (i = 0; i < _NUM_FLD; i++) { 658 errno = 0; 659 int_fld[i] = strtoul(str_fld[i], &end, 0); 660 if (errno != 0 || end == str_fld[i] || int_fld[i] > 255) 661 return -1; 662 } 663 port_id = (portid_t)int_fld[FLD_PORT]; 664 if (port_id_is_invalid(port_id, ENABLED_WARN) || 665 port_id == (portid_t)RTE_PORT_ALL) { 666 print_valid_ports(); 667 return -1; 668 } 669 socket_id = (uint8_t)int_fld[FLD_SOCKET]; 670 if (new_socket_id(socket_id)) { 671 if (num_sockets >= RTE_MAX_NUMA_NODES) { 672 print_invalid_socket_id_error(); 673 return -1; 674 } 675 socket_ids[num_sockets++] = socket_id; 676 } 677 port_numa[port_id] = socket_id; 678 } 679 680 return 0; 681 } 682 683 static int 684 parse_ringnuma_config(const char *q_arg) 685 { 686 char s[256]; 687 const char *p, *p0 = q_arg; 688 char *end; 689 uint8_t i, ring_flag, socket_id; 690 portid_t port_id; 691 unsigned size; 692 enum fieldnames { 693 FLD_PORT = 0, 694 FLD_FLAG, 695 FLD_SOCKET, 696 _NUM_FLD 697 }; 698 unsigned long int_fld[_NUM_FLD]; 699 char *str_fld[_NUM_FLD]; 700 #define RX_RING_ONLY 0x1 701 #define TX_RING_ONLY 0x2 702 #define RXTX_RING 0x3 703 704 /* reset from value set at definition */ 705 while ((p = strchr(p0,'(')) != NULL) { 706 ++p; 707 if((p0 = strchr(p,')')) == NULL) 708 return -1; 709 710 size = p0 - p; 711 if(size >= sizeof(s)) 712 return -1; 713 714 snprintf(s, sizeof(s), "%.*s", size, p); 715 if (rte_strsplit(s, sizeof(s), str_fld, _NUM_FLD, ',') != _NUM_FLD) 716 return -1; 717 for (i = 0; i < _NUM_FLD; i++) { 718 errno = 0; 719 int_fld[i] = strtoul(str_fld[i], &end, 0); 720 if (errno != 0 || end == str_fld[i] || int_fld[i] > 255) 721 return -1; 722 } 723 port_id = (portid_t)int_fld[FLD_PORT]; 724 if (port_id_is_invalid(port_id, ENABLED_WARN) || 725 port_id == (portid_t)RTE_PORT_ALL) { 726 print_valid_ports(); 727 return -1; 728 } 729 socket_id = (uint8_t)int_fld[FLD_SOCKET]; 730 if (new_socket_id(socket_id)) { 731 if (num_sockets >= RTE_MAX_NUMA_NODES) { 732 print_invalid_socket_id_error(); 733 return -1; 734 } 735 socket_ids[num_sockets++] = socket_id; 736 } 737 ring_flag = (uint8_t)int_fld[FLD_FLAG]; 738 if ((ring_flag < RX_RING_ONLY) || (ring_flag > RXTX_RING)) { 739 fprintf(stderr, 740 "Invalid ring-flag=%d config for port =%d\n", 741 ring_flag,port_id); 742 return -1; 743 } 744 745 switch (ring_flag & RXTX_RING) { 746 case RX_RING_ONLY: 747 rxring_numa[port_id] = socket_id; 748 break; 749 case TX_RING_ONLY: 750 txring_numa[port_id] = socket_id; 751 break; 752 case RXTX_RING: 753 rxring_numa[port_id] = socket_id; 754 txring_numa[port_id] = socket_id; 755 break; 756 default: 757 fprintf(stderr, 758 "Invalid ring-flag=%d config for port=%d\n", 759 ring_flag,port_id); 760 break; 761 } 762 } 763 764 return 0; 765 } 766 767 static int 768 parse_event_printing_config(const char *optarg, int enable) 769 { 770 uint32_t mask = 0; 771 772 if (!strcmp(optarg, "unknown")) 773 mask = UINT32_C(1) << RTE_ETH_EVENT_UNKNOWN; 774 else if (!strcmp(optarg, "intr_lsc")) 775 mask = UINT32_C(1) << RTE_ETH_EVENT_INTR_LSC; 776 else if (!strcmp(optarg, "queue_state")) 777 mask = UINT32_C(1) << RTE_ETH_EVENT_QUEUE_STATE; 778 else if (!strcmp(optarg, "intr_reset")) 779 mask = UINT32_C(1) << RTE_ETH_EVENT_INTR_RESET; 780 else if (!strcmp(optarg, "vf_mbox")) 781 mask = UINT32_C(1) << RTE_ETH_EVENT_VF_MBOX; 782 else if (!strcmp(optarg, "ipsec")) 783 mask = UINT32_C(1) << RTE_ETH_EVENT_IPSEC; 784 else if (!strcmp(optarg, "macsec")) 785 mask = UINT32_C(1) << RTE_ETH_EVENT_MACSEC; 786 else if (!strcmp(optarg, "intr_rmv")) 787 mask = UINT32_C(1) << RTE_ETH_EVENT_INTR_RMV; 788 else if (!strcmp(optarg, "dev_probed")) 789 mask = UINT32_C(1) << RTE_ETH_EVENT_NEW; 790 else if (!strcmp(optarg, "dev_released")) 791 mask = UINT32_C(1) << RTE_ETH_EVENT_DESTROY; 792 else if (!strcmp(optarg, "flow_aged")) 793 mask = UINT32_C(1) << RTE_ETH_EVENT_FLOW_AGED; 794 else if (!strcmp(optarg, "err_recovering")) 795 mask = UINT32_C(1) << RTE_ETH_EVENT_ERR_RECOVERING; 796 else if (!strcmp(optarg, "recovery_success")) 797 mask = UINT32_C(1) << RTE_ETH_EVENT_RECOVERY_SUCCESS; 798 else if (!strcmp(optarg, "recovery_failed")) 799 mask = UINT32_C(1) << RTE_ETH_EVENT_RECOVERY_FAILED; 800 else if (!strcmp(optarg, "all")) 801 mask = ~UINT32_C(0); 802 else { 803 fprintf(stderr, "Invalid event: %s\n", optarg); 804 return -1; 805 } 806 if (enable) 807 event_print_mask |= mask; 808 else 809 event_print_mask &= ~mask; 810 return 0; 811 } 812 813 static int 814 parse_xstats_list(const char *in_str, struct rte_eth_xstat_name **xstats, 815 unsigned int *xstats_num) 816 { 817 int max_names_nb, names_nb, nonempty_names_nb; 818 int name, nonempty_name; 819 int stringlen; 820 char **names; 821 char *str; 822 int ret; 823 int i; 824 825 names = NULL; 826 str = strdup(in_str); 827 if (str == NULL) { 828 ret = -ENOMEM; 829 goto out; 830 } 831 stringlen = strlen(str); 832 833 for (i = 0, max_names_nb = 1; str[i] != '\0'; i++) { 834 if (str[i] == ',') 835 max_names_nb++; 836 } 837 838 names = calloc(max_names_nb, sizeof(*names)); 839 if (names == NULL) { 840 ret = -ENOMEM; 841 goto out; 842 } 843 844 names_nb = rte_strsplit(str, stringlen, names, max_names_nb, ','); 845 if (names_nb < 0) { 846 ret = -EINVAL; 847 goto out; 848 } 849 850 nonempty_names_nb = 0; 851 for (i = 0; i < names_nb; i++) { 852 if (names[i][0] == '\0') 853 continue; 854 nonempty_names_nb++; 855 } 856 *xstats = calloc(nonempty_names_nb, sizeof(**xstats)); 857 if (*xstats == NULL) { 858 ret = -ENOMEM; 859 goto out; 860 } 861 862 for (name = nonempty_name = 0; name < names_nb; name++) { 863 if (names[name][0] == '\0') 864 continue; 865 rte_strscpy((*xstats)[nonempty_name].name, names[name], 866 sizeof((*xstats)[nonempty_name].name)); 867 nonempty_name++; 868 } 869 870 *xstats_num = nonempty_names_nb; 871 ret = 0; 872 873 out: 874 free(names); 875 free(str); 876 return ret; 877 } 878 879 static int 880 parse_link_speed(int n) 881 { 882 uint32_t speed = RTE_ETH_LINK_SPEED_FIXED; 883 884 switch (n) { 885 case 1000: 886 speed |= RTE_ETH_LINK_SPEED_1G; 887 break; 888 case 2500: 889 speed |= RTE_ETH_LINK_SPEED_2_5G; 890 break; 891 case 5000: 892 speed |= RTE_ETH_LINK_SPEED_5G; 893 break; 894 case 10000: 895 speed |= RTE_ETH_LINK_SPEED_10G; 896 break; 897 case 25000: 898 speed |= RTE_ETH_LINK_SPEED_25G; 899 break; 900 case 40000: 901 speed |= RTE_ETH_LINK_SPEED_40G; 902 break; 903 case 50000: 904 speed |= RTE_ETH_LINK_SPEED_50G; 905 break; 906 case 100000: 907 speed |= RTE_ETH_LINK_SPEED_100G; 908 break; 909 case 200000: 910 speed |= RTE_ETH_LINK_SPEED_200G; 911 break; 912 case 400000: 913 speed |= RTE_ETH_LINK_SPEED_400G; 914 break; 915 case 100: 916 case 10: 917 default: 918 fprintf(stderr, "Unsupported fixed speed\n"); 919 return 0; 920 } 921 922 return speed; 923 } 924 925 void 926 launch_args_parse(int argc, char** argv) 927 { 928 int n, opt; 929 int opt_idx; 930 portid_t pid; 931 enum { TX, RX }; 932 /* Default offloads for all ports. */ 933 uint64_t rx_offloads = rx_mode.offloads; 934 uint64_t tx_offloads = tx_mode.offloads; 935 struct rte_eth_dev_info dev_info; 936 uint16_t rec_nb_pkts; 937 int ret; 938 939 while ((opt = getopt_long(argc, argv, short_options, long_options, 940 &opt_idx)) != EOF) { 941 switch (opt) { 942 case 'i': 943 printf("Interactive-mode selected\n"); 944 interactive = 1; 945 break; 946 case 'a': 947 printf("Auto-start selected\n"); 948 auto_start = 1; 949 break; 950 case 'h': 951 usage(argv[0]); 952 exit(EXIT_SUCCESS); 953 break; 954 case TESTPMD_OPT_CMDLINE_FILE_NUM: 955 printf("CLI commands to be read from %s\n", 956 optarg); 957 strlcpy(cmdline_filename, optarg, 958 sizeof(cmdline_filename)); 959 break; 960 case TESTPMD_OPT_TX_FIRST_NUM: 961 printf("Ports to start sending a burst of " 962 "packets first\n"); 963 tx_first = 1; 964 break; 965 case TESTPMD_OPT_STATS_PERIOD_NUM: { 966 char *end = NULL; 967 unsigned int n; 968 969 n = strtoul(optarg, &end, 10); 970 if ((optarg[0] == '\0') || (end == NULL) || 971 (*end != '\0')) 972 rte_exit(EXIT_FAILURE, "Invalid stats-period value\n"); 973 974 stats_period = n; 975 break; 976 } 977 case TESTPMD_OPT_DISPLAY_XSTATS_NUM: { 978 char rc; 979 980 rc = parse_xstats_list(optarg, &xstats_display, 981 &xstats_display_num); 982 if (rc != 0) 983 rte_exit(EXIT_FAILURE, 984 "Failed to parse display-xstats argument: %d\n", 985 rc); 986 break; 987 } 988 case TESTPMD_OPT_ETH_PEERS_CONFIGFILE_NUM: 989 if (init_peer_eth_addrs(optarg) != 0) 990 rte_exit(EXIT_FAILURE, 991 "Cannot open logfile\n"); 992 break; 993 case TESTPMD_OPT_ETH_PEER_NUM: { 994 char *port_end; 995 996 errno = 0; 997 n = strtoul(optarg, &port_end, 10); 998 if (errno != 0 || port_end == optarg || *port_end++ != ',') 999 rte_exit(EXIT_FAILURE, 1000 "Invalid eth-peer: %s", optarg); 1001 if (n >= RTE_MAX_ETHPORTS) 1002 rte_exit(EXIT_FAILURE, 1003 "eth-peer: port %d >= RTE_MAX_ETHPORTS(%d)\n", 1004 n, RTE_MAX_ETHPORTS); 1005 1006 if (rte_ether_unformat_addr(port_end, 1007 &peer_eth_addrs[n]) < 0) 1008 rte_exit(EXIT_FAILURE, 1009 "Invalid ethernet address: %s\n", 1010 port_end); 1011 nb_peer_eth_addrs++; 1012 break; 1013 } 1014 case TESTPMD_OPT_TX_IP_NUM: { 1015 struct in_addr in; 1016 char *end; 1017 1018 end = strchr(optarg, ','); 1019 if (end == optarg || !end) 1020 rte_exit(EXIT_FAILURE, 1021 "Invalid tx-ip: %s", optarg); 1022 1023 *end++ = 0; 1024 if (inet_pton(AF_INET, optarg, &in) == 0) 1025 rte_exit(EXIT_FAILURE, 1026 "Invalid source IP address: %s\n", 1027 optarg); 1028 tx_ip_src_addr = rte_be_to_cpu_32(in.s_addr); 1029 1030 if (inet_pton(AF_INET, end, &in) == 0) 1031 rte_exit(EXIT_FAILURE, 1032 "Invalid destination IP address: %s\n", 1033 optarg); 1034 tx_ip_dst_addr = rte_be_to_cpu_32(in.s_addr); 1035 break; 1036 } 1037 case TESTPMD_OPT_TX_UDP_NUM: { 1038 char *end = NULL; 1039 1040 errno = 0; 1041 n = strtoul(optarg, &end, 10); 1042 if (errno != 0 || end == optarg || 1043 n > UINT16_MAX || 1044 !(*end == '\0' || *end == ',')) 1045 rte_exit(EXIT_FAILURE, 1046 "Invalid UDP port: %s\n", 1047 optarg); 1048 tx_udp_src_port = n; 1049 if (*end == ',') { 1050 char *dst = end + 1; 1051 1052 n = strtoul(dst, &end, 10); 1053 if (errno != 0 || end == dst || 1054 n > UINT16_MAX || *end) 1055 rte_exit(EXIT_FAILURE, 1056 "Invalid destination UDP port: %s\n", 1057 dst); 1058 tx_udp_dst_port = n; 1059 } else { 1060 tx_udp_dst_port = n; 1061 } 1062 break; 1063 } 1064 case TESTPMD_OPT_NB_PORTS_NUM: 1065 n = atoi(optarg); 1066 if (n > 0 && n <= nb_ports) 1067 nb_fwd_ports = n; 1068 else 1069 rte_exit(EXIT_FAILURE, 1070 "Invalid port %d\n", n); 1071 break; 1072 case TESTPMD_OPT_NB_CORES_NUM: 1073 n = atoi(optarg); 1074 if (n > 0 && n <= nb_lcores) 1075 nb_fwd_lcores = (uint8_t) n; 1076 else 1077 rte_exit(EXIT_FAILURE, 1078 "nb-cores should be > 0 and <= %d\n", 1079 nb_lcores); 1080 break; 1081 case TESTPMD_OPT_COREMASK_NUM: 1082 parse_fwd_coremask(optarg); 1083 break; 1084 case TESTPMD_OPT_PORTMASK_NUM: 1085 parse_fwd_portmask(optarg); 1086 break; 1087 case TESTPMD_OPT_PORTLIST_NUM: 1088 parse_fwd_portlist(optarg); 1089 break; 1090 case TESTPMD_OPT_NO_NUMA_NUM: 1091 numa_support = 0; 1092 break; 1093 case TESTPMD_OPT_NUMA_NUM: 1094 numa_support = 1; 1095 break; 1096 case TESTPMD_OPT_MP_ANON_NUM: 1097 mp_alloc_type = MP_ALLOC_ANON; 1098 break; 1099 case TESTPMD_OPT_MP_ALLOC_NUM: 1100 if (!strcmp(optarg, "native")) 1101 mp_alloc_type = MP_ALLOC_NATIVE; 1102 else if (!strcmp(optarg, "anon")) 1103 mp_alloc_type = MP_ALLOC_ANON; 1104 else if (!strcmp(optarg, "xmem")) 1105 mp_alloc_type = MP_ALLOC_XMEM; 1106 else if (!strcmp(optarg, "xmemhuge")) 1107 mp_alloc_type = MP_ALLOC_XMEM_HUGE; 1108 else if (!strcmp(optarg, "xbuf")) 1109 mp_alloc_type = MP_ALLOC_XBUF; 1110 else 1111 rte_exit(EXIT_FAILURE, 1112 "mp-alloc %s invalid - must be: " 1113 "native, anon, xmem or xmemhuge\n", 1114 optarg); 1115 break; 1116 case TESTPMD_OPT_PORT_NUMA_CONFIG_NUM: 1117 if (parse_portnuma_config(optarg)) 1118 rte_exit(EXIT_FAILURE, 1119 "invalid port-numa configuration\n"); 1120 break; 1121 case TESTPMD_OPT_RING_NUMA_CONFIG_NUM: 1122 if (parse_ringnuma_config(optarg)) 1123 rte_exit(EXIT_FAILURE, 1124 "invalid ring-numa configuration\n"); 1125 break; 1126 case TESTPMD_OPT_SOCKET_NUM_NUM: 1127 n = atoi(optarg); 1128 if (!new_socket_id((uint8_t)n)) { 1129 socket_num = (uint8_t)n; 1130 } else { 1131 print_invalid_socket_id_error(); 1132 rte_exit(EXIT_FAILURE, 1133 "Invalid socket id"); 1134 } 1135 break; 1136 case TESTPMD_OPT_MBUF_SIZE_NUM: { 1137 unsigned int mb_sz[MAX_SEGS_BUFFER_SPLIT]; 1138 unsigned int nb_segs, i; 1139 1140 nb_segs = parse_item_list(optarg, "mbuf-size", 1141 MAX_SEGS_BUFFER_SPLIT, mb_sz, 0); 1142 if (nb_segs <= 0) 1143 rte_exit(EXIT_FAILURE, 1144 "bad mbuf-size\n"); 1145 for (i = 0; i < nb_segs; i++) { 1146 if (mb_sz[i] <= 0 || mb_sz[i] > 0xFFFF) 1147 rte_exit(EXIT_FAILURE, 1148 "mbuf-size should be " 1149 "> 0 and < 65536\n"); 1150 mbuf_data_size[i] = (uint16_t) mb_sz[i]; 1151 } 1152 mbuf_data_size_n = nb_segs; 1153 break; 1154 } 1155 case TESTPMD_OPT_TOTAL_NUM_MBUFS_NUM: 1156 n = atoi(optarg); 1157 if (n > MIN_TOTAL_NUM_MBUFS) 1158 param_total_num_mbufs = (unsigned int)n; 1159 else 1160 rte_exit(EXIT_FAILURE, 1161 "total-num-mbufs should be > %d\n", 1162 MIN_TOTAL_NUM_MBUFS); 1163 break; 1164 case TESTPMD_OPT_MAX_PKT_LEN_NUM: 1165 n = atoi(optarg); 1166 if (n >= RTE_ETHER_MIN_LEN) 1167 max_rx_pkt_len = n; 1168 else 1169 rte_exit(EXIT_FAILURE, 1170 "Invalid max-pkt-len=%d - should be > %d\n", 1171 n, RTE_ETHER_MIN_LEN); 1172 break; 1173 case TESTPMD_OPT_MAX_LRO_PKT_SIZE_NUM: 1174 n = atoi(optarg); 1175 rx_mode.max_lro_pkt_size = (uint32_t) n; 1176 break; 1177 #ifdef RTE_LIB_LATENCYSTATS 1178 case TESTPMD_OPT_LATENCYSTATS_NUM: 1179 n = atoi(optarg); 1180 if (n >= 0) { 1181 latencystats_lcore_id = (lcoreid_t) n; 1182 latencystats_enabled = 1; 1183 } else 1184 rte_exit(EXIT_FAILURE, 1185 "invalid lcore id %d for latencystats" 1186 " must be >= 0\n", n); 1187 1188 break; 1189 #endif 1190 #ifdef RTE_LIB_BITRATESTATS 1191 case TESTPMD_OPT_BITRATE_STATS_NUM: 1192 n = atoi(optarg); 1193 if (n >= 0) { 1194 bitrate_lcore_id = (lcoreid_t) n; 1195 bitrate_enabled = 1; 1196 } else 1197 rte_exit(EXIT_FAILURE, 1198 "invalid lcore id %d for bitrate stats" 1199 " must be >= 0\n", n); 1200 break; 1201 #endif 1202 case TESTPMD_OPT_DISABLE_CRC_STRIP_NUM: 1203 rx_offloads |= RTE_ETH_RX_OFFLOAD_KEEP_CRC; 1204 break; 1205 case TESTPMD_OPT_ENABLE_LRO_NUM: 1206 rx_offloads |= RTE_ETH_RX_OFFLOAD_TCP_LRO; 1207 break; 1208 case TESTPMD_OPT_ENABLE_SCATTER_NUM: 1209 rx_offloads |= RTE_ETH_RX_OFFLOAD_SCATTER; 1210 break; 1211 case TESTPMD_OPT_ENABLE_RX_CKSUM_NUM: 1212 rx_offloads |= RTE_ETH_RX_OFFLOAD_CHECKSUM; 1213 break; 1214 case TESTPMD_OPT_ENABLE_RX_TIMESTAMP_NUM: 1215 rx_offloads |= RTE_ETH_RX_OFFLOAD_TIMESTAMP; 1216 break; 1217 case TESTPMD_OPT_ENABLE_HW_VLAN_NUM: 1218 rx_offloads |= RTE_ETH_RX_OFFLOAD_VLAN; 1219 break; 1220 case TESTPMD_OPT_ENABLE_HW_VLAN_FILTER_NUM: 1221 rx_offloads |= RTE_ETH_RX_OFFLOAD_VLAN_FILTER; 1222 break; 1223 case TESTPMD_OPT_ENABLE_HW_VLAN_STRIP_NUM: 1224 rx_offloads |= RTE_ETH_RX_OFFLOAD_VLAN_STRIP; 1225 break; 1226 case TESTPMD_OPT_ENABLE_HW_VLAN_EXTEND_NUM: 1227 rx_offloads |= RTE_ETH_RX_OFFLOAD_VLAN_EXTEND; 1228 break; 1229 case TESTPMD_OPT_ENABLE_HW_QINQ_STRIP_NUM: 1230 rx_offloads |= RTE_ETH_RX_OFFLOAD_QINQ_STRIP; 1231 break; 1232 case TESTPMD_OPT_ENABLE_DROP_EN_NUM: 1233 rx_drop_en = 1; 1234 break; 1235 case TESTPMD_OPT_DISABLE_RSS_NUM: 1236 rss_hf = 0; 1237 break; 1238 case TESTPMD_OPT_PORT_TOPOLOGY_NUM: 1239 if (!strcmp(optarg, "paired")) 1240 port_topology = PORT_TOPOLOGY_PAIRED; 1241 else if (!strcmp(optarg, "chained")) 1242 port_topology = PORT_TOPOLOGY_CHAINED; 1243 else if (!strcmp(optarg, "loop")) 1244 port_topology = PORT_TOPOLOGY_LOOP; 1245 else 1246 rte_exit(EXIT_FAILURE, "port-topology %s invalid -" 1247 " must be: paired, chained or loop\n", 1248 optarg); 1249 break; 1250 case TESTPMD_OPT_FORWARD_MODE_NUM: 1251 set_pkt_forwarding_mode(optarg); 1252 break; 1253 case TESTPMD_OPT_RSS_IP_NUM: 1254 rss_hf = RTE_ETH_RSS_IP; 1255 break; 1256 case TESTPMD_OPT_RSS_UDP_NUM: 1257 rss_hf = RTE_ETH_RSS_UDP; 1258 break; 1259 case TESTPMD_OPT_RSS_LEVEL_INNER_NUM: 1260 rss_hf |= RTE_ETH_RSS_LEVEL_INNERMOST; 1261 break; 1262 case TESTPMD_OPT_RSS_LEVEL_OUTER_NUM: 1263 rss_hf |= RTE_ETH_RSS_LEVEL_OUTERMOST; 1264 break; 1265 case TESTPMD_OPT_RXQ_NUM: 1266 n = atoi(optarg); 1267 if (n >= 0 && check_nb_rxq((queueid_t)n) == 0) 1268 nb_rxq = (queueid_t) n; 1269 else 1270 rte_exit(EXIT_FAILURE, "rxq %d invalid - must be" 1271 " >= 0 && <= %u\n", n, 1272 get_allowed_max_nb_rxq(&pid)); 1273 break; 1274 case TESTPMD_OPT_TXQ_NUM: 1275 n = atoi(optarg); 1276 if (n >= 0 && check_nb_txq((queueid_t)n) == 0) 1277 nb_txq = (queueid_t) n; 1278 else 1279 rte_exit(EXIT_FAILURE, "txq %d invalid - must be" 1280 " >= 0 && <= %u\n", n, 1281 get_allowed_max_nb_txq(&pid)); 1282 break; 1283 case TESTPMD_OPT_HAIRPINQ_NUM: 1284 n = atoi(optarg); 1285 if (n >= 0 && 1286 check_nb_hairpinq((queueid_t)n) == 0) 1287 nb_hairpinq = (queueid_t) n; 1288 else 1289 rte_exit(EXIT_FAILURE, "txq %d invalid - must be" 1290 " >= 0 && <= %u\n", n, 1291 get_allowed_max_nb_hairpinq 1292 (&pid)); 1293 if ((n + nb_txq) < 0 || 1294 check_nb_txq((queueid_t)(n + nb_txq)) != 0) 1295 rte_exit(EXIT_FAILURE, "txq + hairpinq " 1296 "%d invalid - must be" 1297 " >= 0 && <= %u\n", 1298 n + nb_txq, 1299 get_allowed_max_nb_txq(&pid)); 1300 if ((n + nb_rxq) < 0 || 1301 check_nb_rxq((queueid_t)(n + nb_rxq)) != 0) 1302 rte_exit(EXIT_FAILURE, "rxq + hairpinq " 1303 "%d invalid - must be" 1304 " >= 0 && <= %u\n", 1305 n + nb_rxq, 1306 get_allowed_max_nb_rxq(&pid)); 1307 break; 1308 case TESTPMD_OPT_HAIRPIN_MODE_NUM: { 1309 char *end = NULL; 1310 unsigned int n; 1311 1312 errno = 0; 1313 n = strtoul(optarg, &end, 0); 1314 if (errno != 0 || end == optarg) 1315 rte_exit(EXIT_FAILURE, "hairpin mode invalid\n"); 1316 else 1317 hairpin_mode = (uint32_t)n; 1318 break; 1319 } 1320 case TESTPMD_OPT_BURST_NUM: 1321 n = atoi(optarg); 1322 if (n == 0) { 1323 /* A burst size of zero means that the 1324 * PMD should be queried for 1325 * recommended Rx burst size. Since 1326 * testpmd uses a single size for all 1327 * ports, port 0 is queried for the 1328 * value, on the assumption that all 1329 * ports are of the same NIC model. 1330 */ 1331 ret = eth_dev_info_get_print_err( 1332 0, 1333 &dev_info); 1334 if (ret != 0) 1335 rte_exit(EXIT_FAILURE, "Failed to get driver " 1336 "recommended burst size, please provide a " 1337 "value between 1 and %d\n", MAX_PKT_BURST); 1338 1339 rec_nb_pkts = dev_info 1340 .default_rxportconf.burst_size; 1341 1342 if (rec_nb_pkts == 0) 1343 rte_exit(EXIT_FAILURE, 1344 "PMD does not recommend a burst size. " 1345 "Provided value must be between " 1346 "1 and %d\n", MAX_PKT_BURST); 1347 else if (rec_nb_pkts > MAX_PKT_BURST) 1348 rte_exit(EXIT_FAILURE, 1349 "PMD recommended burst size of %d" 1350 " exceeds maximum value of %d\n", 1351 rec_nb_pkts, MAX_PKT_BURST); 1352 printf("Using PMD-provided burst value of %d\n", 1353 rec_nb_pkts); 1354 nb_pkt_per_burst = rec_nb_pkts; 1355 } else if (n > MAX_PKT_BURST) 1356 rte_exit(EXIT_FAILURE, 1357 "burst must be between1 and %d\n", 1358 MAX_PKT_BURST); 1359 else 1360 nb_pkt_per_burst = (uint16_t) n; 1361 break; 1362 case TESTPMD_OPT_FLOWGEN_CLONES_NUM: 1363 n = atoi(optarg); 1364 if (n >= 0) 1365 nb_pkt_flowgen_clones = (uint16_t) n; 1366 else 1367 rte_exit(EXIT_FAILURE, 1368 "clones must be >= 0 and <= current burst\n"); 1369 break; 1370 case TESTPMD_OPT_FLOWGEN_FLOWS_NUM: 1371 n = atoi(optarg); 1372 if (n > 0) 1373 nb_flows_flowgen = (int) n; 1374 else 1375 rte_exit(EXIT_FAILURE, 1376 "flows must be >= 1\n"); 1377 break; 1378 case TESTPMD_OPT_MBCACHE_NUM: 1379 n = atoi(optarg); 1380 if ((n >= 0) && 1381 (n <= RTE_MEMPOOL_CACHE_MAX_SIZE)) 1382 mb_mempool_cache = (uint16_t) n; 1383 else 1384 rte_exit(EXIT_FAILURE, 1385 "mbcache must be >= 0 and <= %d\n", 1386 RTE_MEMPOOL_CACHE_MAX_SIZE); 1387 break; 1388 case TESTPMD_OPT_TXFREET_NUM: 1389 n = atoi(optarg); 1390 if (n >= 0) 1391 tx_free_thresh = (int16_t)n; 1392 else 1393 rte_exit(EXIT_FAILURE, "txfreet must be >= 0\n"); 1394 break; 1395 case TESTPMD_OPT_TXRST_NUM: 1396 n = atoi(optarg); 1397 if (n >= 0) 1398 tx_rs_thresh = (int16_t)n; 1399 else 1400 rte_exit(EXIT_FAILURE, "txrst must be >= 0\n"); 1401 break; 1402 case TESTPMD_OPT_RXD_NUM: 1403 n = atoi(optarg); 1404 if (n > 0) { 1405 if (rx_free_thresh >= n) 1406 rte_exit(EXIT_FAILURE, 1407 "rxd must be > " 1408 "rx_free_thresh(%d)\n", 1409 (int)rx_free_thresh); 1410 else 1411 nb_rxd = (uint16_t) n; 1412 } else 1413 rte_exit(EXIT_FAILURE, 1414 "rxd(%d) invalid - must be > 0\n", 1415 n); 1416 break; 1417 case TESTPMD_OPT_TXD_NUM: 1418 n = atoi(optarg); 1419 if (n > 0) 1420 nb_txd = (uint16_t) n; 1421 else 1422 rte_exit(EXIT_FAILURE, "txd must be in > 0\n"); 1423 break; 1424 case TESTPMD_OPT_TXPT_NUM: 1425 n = atoi(optarg); 1426 if (n >= 0) 1427 tx_pthresh = (int8_t)n; 1428 else 1429 rte_exit(EXIT_FAILURE, "txpt must be >= 0\n"); 1430 break; 1431 case TESTPMD_OPT_TXHT_NUM: 1432 n = atoi(optarg); 1433 if (n >= 0) 1434 tx_hthresh = (int8_t)n; 1435 else 1436 rte_exit(EXIT_FAILURE, "txht must be >= 0\n"); 1437 break; 1438 case TESTPMD_OPT_TXWT_NUM: 1439 n = atoi(optarg); 1440 if (n >= 0) 1441 tx_wthresh = (int8_t)n; 1442 else 1443 rte_exit(EXIT_FAILURE, "txwt must be >= 0\n"); 1444 break; 1445 case TESTPMD_OPT_RXPT_NUM: 1446 n = atoi(optarg); 1447 if (n >= 0) 1448 rx_pthresh = (int8_t)n; 1449 else 1450 rte_exit(EXIT_FAILURE, "rxpt must be >= 0\n"); 1451 break; 1452 case TESTPMD_OPT_RXHT_NUM: 1453 n = atoi(optarg); 1454 if (n >= 0) 1455 rx_hthresh = (int8_t)n; 1456 else 1457 rte_exit(EXIT_FAILURE, "rxht must be >= 0\n"); 1458 break; 1459 case TESTPMD_OPT_RXWT_NUM: 1460 n = atoi(optarg); 1461 if (n >= 0) 1462 rx_wthresh = (int8_t)n; 1463 else 1464 rte_exit(EXIT_FAILURE, "rxwt must be >= 0\n"); 1465 break; 1466 case TESTPMD_OPT_RXFREET_NUM: 1467 n = atoi(optarg); 1468 if (n >= 0) 1469 rx_free_thresh = (int16_t)n; 1470 else 1471 rte_exit(EXIT_FAILURE, "rxfreet must be >= 0\n"); 1472 break; 1473 case TESTPMD_OPT_RXOFFS_NUM: { 1474 unsigned int seg_off[MAX_SEGS_BUFFER_SPLIT]; 1475 unsigned int nb_offs; 1476 1477 nb_offs = parse_item_list 1478 (optarg, "rxpkt offsets", 1479 MAX_SEGS_BUFFER_SPLIT, 1480 seg_off, 0); 1481 if (nb_offs > 0) 1482 set_rx_pkt_offsets(seg_off, nb_offs); 1483 else 1484 rte_exit(EXIT_FAILURE, "bad rxoffs\n"); 1485 break; 1486 } 1487 case TESTPMD_OPT_RXPKTS_NUM: { 1488 unsigned int seg_len[MAX_SEGS_BUFFER_SPLIT]; 1489 unsigned int nb_segs; 1490 1491 nb_segs = parse_item_list 1492 (optarg, "rxpkt segments", 1493 MAX_SEGS_BUFFER_SPLIT, 1494 seg_len, 0); 1495 if (nb_segs > 0) 1496 set_rx_pkt_segments(seg_len, nb_segs); 1497 else 1498 rte_exit(EXIT_FAILURE, "bad rxpkts\n"); 1499 break; 1500 } 1501 case TESTPMD_OPT_RXHDRS_NUM: { 1502 unsigned int seg_hdrs[MAX_SEGS_BUFFER_SPLIT]; 1503 unsigned int nb_segs; 1504 1505 nb_segs = parse_hdrs_list 1506 (optarg, "rxpkt segments", 1507 MAX_SEGS_BUFFER_SPLIT, 1508 seg_hdrs); 1509 if (nb_segs > 0) 1510 set_rx_pkt_hdrs(seg_hdrs, nb_segs); 1511 else 1512 rte_exit(EXIT_FAILURE, "bad rxpkts\n"); 1513 break; 1514 } 1515 case TESTPMD_OPT_TXPKTS_NUM: { 1516 unsigned int seg_lengths[RTE_MAX_SEGS_PER_PKT]; 1517 unsigned int nb_segs; 1518 1519 nb_segs = parse_item_list(optarg, "txpkt segments", 1520 RTE_MAX_SEGS_PER_PKT, seg_lengths, 0); 1521 if (nb_segs > 0) 1522 set_tx_pkt_segments(seg_lengths, nb_segs); 1523 else 1524 rte_exit(EXIT_FAILURE, "bad txpkts\n"); 1525 break; 1526 } 1527 case TESTPMD_OPT_MULTI_RX_MEMPOOL_NUM: 1528 multi_rx_mempool = 1; 1529 break; 1530 case TESTPMD_OPT_TXONLY_MULTI_FLOW_NUM: 1531 txonly_multi_flow = 1; 1532 break; 1533 case TESTPMD_OPT_RXQ_SHARE_NUM: 1534 if (optarg == NULL) { 1535 rxq_share = UINT32_MAX; 1536 } else { 1537 n = atoi(optarg); 1538 if (n >= 0) 1539 rxq_share = (uint32_t)n; 1540 else 1541 rte_exit(EXIT_FAILURE, "rxq-share must be >= 0\n"); 1542 } 1543 break; 1544 case TESTPMD_OPT_NO_FLUSH_RX_NUM: 1545 no_flush_rx = 1; 1546 break; 1547 case TESTPMD_OPT_ETH_LINK_SPEED_NUM: 1548 n = atoi(optarg); 1549 if (n >= 0 && parse_link_speed(n) > 0) 1550 eth_link_speed = parse_link_speed(n); 1551 break; 1552 case TESTPMD_OPT_DISABLE_LINK_CHECK_NUM: 1553 no_link_check = 1; 1554 break; 1555 case TESTPMD_OPT_DISABLE_DEVICE_START_NUM: 1556 no_device_start = 1; 1557 break; 1558 case TESTPMD_OPT_NO_LSC_INTERRUPT_NUM: 1559 lsc_interrupt = 0; 1560 break; 1561 case TESTPMD_OPT_NO_RMV_INTERRUPT_NUM: 1562 rmv_interrupt = 0; 1563 break; 1564 case TESTPMD_OPT_FLOW_ISOLATE_ALL_NUM: 1565 flow_isolate_all = 1; 1566 break; 1567 case TESTPMD_OPT_DISABLE_FLOW_FLUSH_NUM: 1568 no_flow_flush = 1; 1569 break; 1570 case TESTPMD_OPT_TX_OFFLOADS_NUM: { 1571 char *end = NULL; 1572 1573 n = strtoull(optarg, &end, 16); 1574 if (n >= 0) 1575 tx_offloads = (uint64_t)n; 1576 else 1577 rte_exit(EXIT_FAILURE, 1578 "tx-offloads must be >= 0\n"); 1579 break; 1580 } 1581 case TESTPMD_OPT_RX_OFFLOADS_NUM: { 1582 char *end = NULL; 1583 1584 n = strtoull(optarg, &end, 16); 1585 if (n >= 0) 1586 rx_offloads = (uint64_t)n; 1587 else 1588 rte_exit(EXIT_FAILURE, 1589 "rx-offloads must be >= 0\n"); 1590 break; 1591 } 1592 case TESTPMD_OPT_VXLAN_GPE_PORT_NUM: 1593 n = atoi(optarg); 1594 if (n >= 0) 1595 vxlan_gpe_udp_port = (uint16_t)n; 1596 else 1597 rte_exit(EXIT_FAILURE, 1598 "vxlan-gpe-port must be >= 0\n"); 1599 break; 1600 case TESTPMD_OPT_GENEVE_PARSED_PORT_NUM: 1601 n = atoi(optarg); 1602 if (n >= 0) 1603 geneve_udp_port = (uint16_t)n; 1604 else 1605 rte_exit(EXIT_FAILURE, 1606 "geneve-parsed-port must be >= 0\n"); 1607 break; 1608 case TESTPMD_OPT_PRINT_EVENT_NUM: 1609 if (parse_event_printing_config(optarg, 1)) { 1610 rte_exit(EXIT_FAILURE, 1611 "invalid print-event argument\n"); 1612 } 1613 break; 1614 case TESTPMD_OPT_MASK_EVENT_NUM: 1615 if (parse_event_printing_config(optarg, 0)) { 1616 rte_exit(EXIT_FAILURE, 1617 "invalid mask-event argument\n"); 1618 } 1619 break; 1620 case TESTPMD_OPT_HOT_PLUG_NUM: 1621 hot_plug = 1; 1622 break; 1623 case TESTPMD_OPT_MLOCKALL_NUM: 1624 do_mlockall = 1; 1625 break; 1626 case TESTPMD_OPT_NO_MLOCKALL_NUM: 1627 do_mlockall = 0; 1628 break; 1629 case TESTPMD_OPT_NOISY_TX_SW_BUFFER_SIZE_NUM: 1630 n = atoi(optarg); 1631 if (n >= 0) 1632 noisy_tx_sw_bufsz = n; 1633 else 1634 rte_exit(EXIT_FAILURE, 1635 "noisy-tx-sw-buffer-size must be >= 0\n"); 1636 break; 1637 case TESTPMD_OPT_NOISY_TX_SW_BUFFER_FLUSHTIME_NUM: 1638 n = atoi(optarg); 1639 if (n >= 0) 1640 noisy_tx_sw_buf_flush_time = n; 1641 else 1642 rte_exit(EXIT_FAILURE, 1643 "noisy-tx-sw-buffer-flushtime must be >= 0\n"); 1644 break; 1645 case TESTPMD_OPT_NOISY_LKUP_MEMORY_NUM: 1646 n = atoi(optarg); 1647 if (n >= 0) 1648 noisy_lkup_mem_sz = n; 1649 else 1650 rte_exit(EXIT_FAILURE, 1651 "noisy-lkup-memory must be >= 0\n"); 1652 break; 1653 case TESTPMD_OPT_NOISY_LKUP_NUM_WRITES_NUM: 1654 n = atoi(optarg); 1655 if (n >= 0) 1656 noisy_lkup_num_writes = n; 1657 else 1658 rte_exit(EXIT_FAILURE, 1659 "noisy-lkup-num-writes must be >= 0\n"); 1660 break; 1661 case TESTPMD_OPT_NOISY_LKUP_NUM_READS_NUM: 1662 n = atoi(optarg); 1663 if (n >= 0) 1664 noisy_lkup_num_reads = n; 1665 else 1666 rte_exit(EXIT_FAILURE, 1667 "noisy-lkup-num-reads must be >= 0\n"); 1668 break; 1669 case TESTPMD_OPT_NOISY_LKUP_NUM_READS_WRITES_NUM: 1670 n = atoi(optarg); 1671 if (n >= 0) 1672 noisy_lkup_num_reads_writes = n; 1673 else 1674 rte_exit(EXIT_FAILURE, 1675 "noisy-lkup-num-reads-writes must be >= 0\n"); 1676 break; 1677 case TESTPMD_OPT_NOISY_FORWARD_MODE_NUM: { 1678 unsigned int i; 1679 1680 for (i = 0; i < NOISY_FWD_MODE_MAX; i++) { 1681 if (!strcmp(optarg, noisy_fwd_mode_desc[i])) { 1682 noisy_fwd_mode = i; 1683 break; 1684 } 1685 } 1686 if (i == NOISY_FWD_MODE_MAX) 1687 rte_exit(EXIT_FAILURE, "noisy-forward-mode %s invalid," 1688 " must be a valid noisy-forward-mode value\n", 1689 optarg); 1690 break; 1691 } 1692 case TESTPMD_OPT_NO_IOVA_CONTIG_NUM: 1693 mempool_flags = RTE_MEMPOOL_F_NO_IOVA_CONTIG; 1694 break; 1695 case TESTPMD_OPT_RX_MQ_MODE_NUM: { 1696 char *end = NULL; 1697 1698 n = strtoul(optarg, &end, 16); 1699 if (n >= 0 && n <= RTE_ETH_MQ_RX_VMDQ_DCB_RSS) 1700 rx_mq_mode = (enum rte_eth_rx_mq_mode)n; 1701 else 1702 rte_exit(EXIT_FAILURE, 1703 "rx-mq-mode must be >= 0 and <= %d\n", 1704 RTE_ETH_MQ_RX_VMDQ_DCB_RSS); 1705 break; 1706 } 1707 case TESTPMD_OPT_RECORD_CORE_CYCLES_NUM: 1708 record_core_cycles = 1; 1709 break; 1710 case TESTPMD_OPT_RECORD_BURST_STATS_NUM: 1711 record_burst_stats = 1; 1712 break; 1713 case TESTPMD_OPT_NUM_PROCS_NUM: 1714 num_procs = atoi(optarg); 1715 break; 1716 case TESTPMD_OPT_PROC_ID_NUM: 1717 proc_id = atoi(optarg); 1718 break; 1719 default: 1720 usage(argv[0]); 1721 fprintf(stderr, "Invalid option: %s\n", argv[optind - 1]); 1722 rte_exit(EXIT_FAILURE, 1723 "Command line is incomplete or incorrect\n"); 1724 break; 1725 } 1726 } 1727 1728 if (optind != argc) { 1729 usage(argv[0]); 1730 fprintf(stderr, "Invalid parameter: %s\n", argv[optind]); 1731 rte_exit(EXIT_FAILURE, "Command line is incorrect\n"); 1732 } 1733 1734 if (proc_id >= (int)num_procs) 1735 rte_exit(EXIT_FAILURE, 1736 "The multi-process option '%s(%d)' should be less than '%s(%u)'\n", 1737 TESTPMD_OPT_PROC_ID, proc_id, 1738 TESTPMD_OPT_NUM_PROCS, num_procs); 1739 1740 /* Set offload configuration from command line parameters. */ 1741 rx_mode.offloads = rx_offloads; 1742 tx_mode.offloads = tx_offloads; 1743 1744 if (mempool_flags & RTE_MEMPOOL_F_NO_IOVA_CONTIG && 1745 mp_alloc_type != MP_ALLOC_ANON) { 1746 TESTPMD_LOG(WARNING, "cannot use no-iova-contig without " 1747 "mp-alloc=anon. mempool no-iova-contig is " 1748 "ignored\n"); 1749 mempool_flags = 0; 1750 } 1751 } 1752