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