4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42 #include <sys/queue.h>
45 #include <rte_common.h>
46 #include <rte_byteorder.h>
48 #include <rte_debug.h>
49 #include <rte_cycles.h>
50 #include <rte_memory.h>
51 #include <rte_memcpy.h>
52 #include <rte_memzone.h>
53 #include <rte_launch.h>
55 #include <rte_per_lcore.h>
56 #include <rte_lcore.h>
57 #include <rte_atomic.h>
58 #include <rte_branch_prediction.h>
59 #include <rte_memory.h>
60 #include <rte_mempool.h>
62 #include <rte_interrupts.h>
64 #include <rte_ether.h>
65 #include <rte_ethdev.h>
66 #include <rte_string_fns.h>
74 print_ether_addr(const char *what
, struct ether_addr
*eth_addr
)
76 char buf
[ETHER_ADDR_FMT_SIZE
];
77 ether_format_addr(buf
, ETHER_ADDR_FMT_SIZE
, eth_addr
);
78 printf("%s%s", what
, buf
);
82 * Received a burst of packets.
85 pkt_burst_receive(struct fwd_stream
*fs
)
87 struct rte_mbuf
*pkts_burst
[MAX_PKT_BURST
];
89 struct ether_hdr
*eth_hdr
;
93 uint16_t i
, packet_type
;
94 uint16_t is_encapsulation
;
96 struct rte_net_hdr_lens hdr_lens
;
97 uint32_t sw_packet_type
;
99 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
102 uint64_t core_cycles
;
105 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
106 start_tsc
= rte_rdtsc();
110 * Receive a burst of packets.
112 nb_rx
= rte_eth_rx_burst(fs
->rx_port
, fs
->rx_queue
, pkts_burst
,
114 if (unlikely(nb_rx
== 0))
117 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
118 fs
->rx_burst_stats
.pkt_burst_spread
[nb_rx
]++;
120 fs
->rx_packets
+= nb_rx
;
123 * Dump each received packet if verbose_level > 0.
125 if (verbose_level
> 0)
126 printf("port %u/queue %u: received %u packets\n",
127 (unsigned) fs
->rx_port
,
128 (unsigned) fs
->rx_queue
,
130 for (i
= 0; i
< nb_rx
; i
++) {
132 if (verbose_level
== 0) {
133 rte_pktmbuf_free(mb
);
136 eth_hdr
= rte_pktmbuf_mtod(mb
, struct ether_hdr
*);
137 eth_type
= RTE_BE_TO_CPU_16(eth_hdr
->ether_type
);
138 ol_flags
= mb
->ol_flags
;
139 packet_type
= mb
->packet_type
;
140 is_encapsulation
= RTE_ETH_IS_TUNNEL_PKT(packet_type
);
142 print_ether_addr(" src=", ð_hdr
->s_addr
);
143 print_ether_addr(" - dst=", ð_hdr
->d_addr
);
144 printf(" - type=0x%04x - length=%u - nb_segs=%d",
145 eth_type
, (unsigned) mb
->pkt_len
,
147 if (ol_flags
& PKT_RX_RSS_HASH
) {
148 printf(" - RSS hash=0x%x", (unsigned) mb
->hash
.rss
);
149 printf(" - RSS queue=0x%x",(unsigned) fs
->rx_queue
);
150 } else if (ol_flags
& PKT_RX_FDIR
) {
151 printf(" - FDIR matched ");
152 if (ol_flags
& PKT_RX_FDIR_ID
)
155 else if (ol_flags
& PKT_RX_FDIR_FLX
)
156 printf("flex bytes=0x%08x %08x",
157 mb
->hash
.fdir
.hi
, mb
->hash
.fdir
.lo
);
159 printf("hash=0x%x ID=0x%x ",
160 mb
->hash
.fdir
.hash
, mb
->hash
.fdir
.id
);
162 if (ol_flags
& PKT_RX_VLAN_STRIPPED
)
163 printf(" - VLAN tci=0x%x", mb
->vlan_tci
);
164 if (ol_flags
& PKT_RX_QINQ_STRIPPED
)
165 printf(" - QinQ VLAN tci=0x%x, VLAN tci outer=0x%x",
166 mb
->vlan_tci
, mb
->vlan_tci_outer
);
167 if (mb
->packet_type
) {
168 rte_get_ptype_name(mb
->packet_type
, buf
, sizeof(buf
));
169 printf(" - hw ptype: %s", buf
);
171 sw_packet_type
= rte_net_get_ptype(mb
, &hdr_lens
,
173 rte_get_ptype_name(sw_packet_type
, buf
, sizeof(buf
));
174 printf(" - sw ptype: %s", buf
);
175 if (sw_packet_type
& RTE_PTYPE_L2_MASK
)
176 printf(" - l2_len=%d", hdr_lens
.l2_len
);
177 if (sw_packet_type
& RTE_PTYPE_L3_MASK
)
178 printf(" - l3_len=%d", hdr_lens
.l3_len
);
179 if (sw_packet_type
& RTE_PTYPE_L4_MASK
)
180 printf(" - l4_len=%d", hdr_lens
.l4_len
);
181 if (sw_packet_type
& RTE_PTYPE_TUNNEL_MASK
)
182 printf(" - tunnel_len=%d", hdr_lens
.tunnel_len
);
183 if (sw_packet_type
& RTE_PTYPE_INNER_L2_MASK
)
184 printf(" - inner_l2_len=%d", hdr_lens
.inner_l2_len
);
185 if (sw_packet_type
& RTE_PTYPE_INNER_L3_MASK
)
186 printf(" - inner_l3_len=%d", hdr_lens
.inner_l3_len
);
187 if (sw_packet_type
& RTE_PTYPE_INNER_L4_MASK
)
188 printf(" - inner_l4_len=%d", hdr_lens
.inner_l4_len
);
189 if (is_encapsulation
) {
190 struct ipv4_hdr
*ipv4_hdr
;
191 struct ipv6_hdr
*ipv6_hdr
;
192 struct udp_hdr
*udp_hdr
;
197 struct vxlan_hdr
*vxlan_hdr
;
199 l2_len
= sizeof(struct ether_hdr
);
201 /* Do not support ipv4 option field */
202 if (RTE_ETH_IS_IPV4_HDR(packet_type
)) {
203 l3_len
= sizeof(struct ipv4_hdr
);
204 ipv4_hdr
= rte_pktmbuf_mtod_offset(mb
,
207 l4_proto
= ipv4_hdr
->next_proto_id
;
209 l3_len
= sizeof(struct ipv6_hdr
);
210 ipv6_hdr
= rte_pktmbuf_mtod_offset(mb
,
213 l4_proto
= ipv6_hdr
->proto
;
215 if (l4_proto
== IPPROTO_UDP
) {
216 udp_hdr
= rte_pktmbuf_mtod_offset(mb
,
219 l4_len
= sizeof(struct udp_hdr
);
220 vxlan_hdr
= rte_pktmbuf_mtod_offset(mb
,
222 l2_len
+ l3_len
+ l4_len
);
224 printf(" - VXLAN packet: packet type =%d, "
225 "Destination UDP port =%d, VNI = %d",
226 packet_type
, RTE_BE_TO_CPU_16(udp_hdr
->dst_port
),
227 rte_be_to_cpu_32(vxlan_hdr
->vx_vni
) >> 8);
230 printf(" - Receive queue=0x%x", (unsigned) fs
->rx_queue
);
232 rte_get_rx_ol_flag_list(mb
->ol_flags
, buf
, sizeof(buf
));
233 printf(" ol_flags: %s\n", buf
);
234 rte_pktmbuf_free(mb
);
237 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
238 end_tsc
= rte_rdtsc();
239 core_cycles
= (end_tsc
- start_tsc
);
240 fs
->core_cycles
= (uint64_t) (fs
->core_cycles
+ core_cycles
);
244 struct fwd_engine rx_only_engine
= {
245 .fwd_mode_name
= "rxonly",
246 .port_fwd_begin
= NULL
,
247 .port_fwd_end
= NULL
,
248 .packet_fwd
= pkt_burst_receive
,