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