app/testpmd: support hairpin
[dpdk.git] / app / test-pmd / macfwd.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <stdarg.h>
6 #include <string.h>
7 #include <stdio.h>
8 #include <errno.h>
9 #include <stdint.h>
10 #include <unistd.h>
11 #include <inttypes.h>
12
13 #include <sys/queue.h>
14 #include <sys/stat.h>
15
16 #include <rte_common.h>
17 #include <rte_byteorder.h>
18 #include <rte_log.h>
19 #include <rte_debug.h>
20 #include <rte_cycles.h>
21 #include <rte_memory.h>
22 #include <rte_memcpy.h>
23 #include <rte_launch.h>
24 #include <rte_eal.h>
25 #include <rte_per_lcore.h>
26 #include <rte_lcore.h>
27 #include <rte_atomic.h>
28 #include <rte_branch_prediction.h>
29 #include <rte_mempool.h>
30 #include <rte_mbuf.h>
31 #include <rte_interrupts.h>
32 #include <rte_pci.h>
33 #include <rte_ether.h>
34 #include <rte_ethdev.h>
35 #include <rte_ip.h>
36 #include <rte_string_fns.h>
37 #include <rte_flow.h>
38
39 #include "testpmd.h"
40
41 /*
42  * Forwarding of packets in MAC mode.
43  * Change the source and the destination Ethernet addressed of packets
44  * before forwarding them.
45  */
46 static void
47 pkt_burst_mac_forward(struct fwd_stream *fs)
48 {
49         struct rte_mbuf  *pkts_burst[MAX_PKT_BURST];
50         struct rte_port  *txp;
51         struct rte_mbuf  *mb;
52         struct rte_ether_hdr *eth_hdr;
53         uint32_t retry;
54         uint16_t nb_rx;
55         uint16_t nb_tx;
56         uint16_t i;
57         uint64_t ol_flags = 0;
58         uint64_t tx_offloads;
59 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
60         uint64_t start_tsc;
61         uint64_t end_tsc;
62         uint64_t core_cycles;
63 #endif
64
65 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
66         start_tsc = rte_rdtsc();
67 #endif
68
69         /*
70          * Receive a burst of packets and forward them.
71          */
72         nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
73                                  nb_pkt_per_burst);
74         if (unlikely(nb_rx == 0))
75                 return;
76
77 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
78         fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
79 #endif
80         fs->rx_packets += nb_rx;
81         txp = &ports[fs->tx_port];
82         tx_offloads = txp->dev_conf.txmode.offloads;
83         if (tx_offloads & DEV_TX_OFFLOAD_VLAN_INSERT)
84                 ol_flags = PKT_TX_VLAN_PKT;
85         if (tx_offloads & DEV_TX_OFFLOAD_QINQ_INSERT)
86                 ol_flags |= PKT_TX_QINQ_PKT;
87         if (tx_offloads & DEV_TX_OFFLOAD_MACSEC_INSERT)
88                 ol_flags |= PKT_TX_MACSEC;
89         for (i = 0; i < nb_rx; i++) {
90                 if (likely(i < nb_rx - 1))
91                         rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i + 1],
92                                                        void *));
93                 mb = pkts_burst[i];
94                 eth_hdr = rte_pktmbuf_mtod(mb, struct rte_ether_hdr *);
95                 rte_ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
96                                 &eth_hdr->d_addr);
97                 rte_ether_addr_copy(&ports[fs->tx_port].eth_addr,
98                                 &eth_hdr->s_addr);
99                 mb->ol_flags &= IND_ATTACHED_MBUF | EXT_ATTACHED_MBUF;
100                 mb->ol_flags |= ol_flags;
101                 mb->l2_len = sizeof(struct rte_ether_hdr);
102                 mb->l3_len = sizeof(struct rte_ipv4_hdr);
103                 mb->vlan_tci = txp->tx_vlan_id;
104                 mb->vlan_tci_outer = txp->tx_vlan_id_outer;
105         }
106         nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
107         /*
108          * Retry if necessary
109          */
110         if (unlikely(nb_tx < nb_rx) && fs->retry_enabled) {
111                 retry = 0;
112                 while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
113                         rte_delay_us(burst_tx_delay_time);
114                         nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
115                                         &pkts_burst[nb_tx], nb_rx - nb_tx);
116                 }
117         }
118
119         fs->tx_packets += nb_tx;
120 #ifdef RTE_TEST_PMD_RECORD_BURST_STATS
121         fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
122 #endif
123         if (unlikely(nb_tx < nb_rx)) {
124                 fs->fwd_dropped += (nb_rx - nb_tx);
125                 do {
126                         rte_pktmbuf_free(pkts_burst[nb_tx]);
127                 } while (++nb_tx < nb_rx);
128         }
129 #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
130         end_tsc = rte_rdtsc();
131         core_cycles = (end_tsc - start_tsc);
132         fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
133 #endif
134 }
135
136 struct fwd_engine mac_fwd_engine = {
137         .fwd_mode_name  = "mac",
138         .port_fwd_begin = NULL,
139         .port_fwd_end   = NULL,
140         .packet_fwd     = pkt_burst_mac_forward,
141 };