[dpdk-dev] [RFC] testpmd: handle UFO packets

[Jianfeng Tan <jianfeng.tan@intel.com>]

Mostly likely, we will make UFO as a kind of GSO engine.

For short term, we can just call APIs in librte_ip_frag to fragment.

To test:

1. start testpmd with two vhost port.
 $ set fwd csum
 $ start

2. start vm0 connected to vhost0;
 $ ifconfig xxx 1.1.1.1/24 up
 $ ethtool -K xxx ufo on

3. start vm1 connected to vhost1;
 $ ifconfig xxx 1.1.1.2/24 up
 $ ethtool -K xxx ufo on
 $ (Fill a large file named 1.txt)
 $ cat 1.txt | socat - udp-sendto:1.1.1.1:5000

Signed-off-by: Jianfeng Tan <jianfeng.tan@intel.com>
---
 app/test-pmd/csumonly.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)

diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c
index 5f5ab64..3e4c414 100644
--- a/app/test-pmd/csumonly.c
+++ b/app/test-pmd/csumonly.c
@@ -41,6 +41,7 @@
 #include <rte_flow.h>
 #include <rte_gro.h>
 #include <rte_gso.h>
+#include <rte_ip_frag.h>
 
 #include "testpmd.h"
 
@@ -574,6 +575,75 @@ pkt_copy_split(const struct rte_mbuf *pkt)
 	return md[0];
 }
 
+static inline void
+frag_v4_fixup(const struct rte_mbuf *ms, struct rte_mbuf *mf)
+{
+	struct ipv4_hdr *l3h;
+
+	mf->ol_flags = ms->ol_flags;
+	mf->tx_offload = ms->tx_offload;
+
+	if ((ms->ol_flags & PKT_TX_IP_CKSUM) == 0) {
+		l3h = rte_pktmbuf_mtod(mf, struct ipv4_hdr *);
+		l3h->hdr_checksum = rte_ipv4_cksum(l3h);
+	}
+}
+
+/*
+ * Returns negative for failure to fragment or actual number of fragments.
+ */
+static inline int
+fragment(struct rte_mbuf *m, struct rte_mbuf *frag[], uint32_t num)
+{
+	void *l2;
+	int l2_len;
+	int32_t frag_num, i;
+	uint16_t ether_type;
+	struct ether_hdr *eth_hdr;
+
+	eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *); 
+	ether_type = eth_hdr->ether_type;
+	m->l2_len = sizeof(*eth_hdr);
+	if (ether_type == ETHER_TYPE_VLAN) {
+		struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1); 
+		ether_type = rte_be_to_cpu_16(vlan_hdr->eth_proto);
+		m->l2_len += sizeof(struct vlan_hdr);
+	}
+	l2_len = m->l2_len;
+
+	/* store the l2 header */
+	uint8_t l2_hdr[l2_len];
+	rte_memcpy(l2_hdr, eth_hdr, l2_len);
+
+	/* Remove the l2 header from the input packet */
+	rte_pktmbuf_adj(m, l2_len);
+
+	if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
+		frag_num = rte_ipv4_fragment_packet(m, frag, num,
+			m->tso_segsz, current_fwd_lcore()->mbp,
+			current_fwd_lcore()->mbp);
+	else
+		frag_num = rte_ipv6_fragment_packet(m, frag, num,
+			m->tso_segsz, current_fwd_lcore()->mbp,
+			current_fwd_lcore()->mbp);
+
+	if (frag_num > 0) {
+		for (i = 0; i != frag_num; i++) {
+
+			if (ether_type == rte_cpu_to_be_16(ETHER_TYPE_IPv4))
+				frag_v4_fixup(m, frag[i]);
+
+			/* Move data_off to include l2 header first */
+			l2 = rte_pktmbuf_prepend(frag[i], l2_len);
+
+			/* copy l2 header into fragmented packet */
+			rte_memcpy(l2, l2_hdr, l2_len);
+		}
+	}
+
+	return frag_num;
+}
+
 /*
  * Receive a burst of packets, and for each packet:
  *  - parse packet, and try to recognize a supported packet type (1)
@@ -603,6 +673,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 {
 	struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
 	struct rte_mbuf *gso_segments[GSO_MAX_PKT_BURST];
+	struct rte_mbuf *ufo_segments[GSO_MAX_PKT_BURST];
 	struct rte_gso_ctx *gso_ctx;
 	struct rte_mbuf **tx_pkts_burst;
 	struct rte_port *txp;
@@ -656,6 +727,32 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 	if (gso_ports[fs->tx_port].enable)
 		info.gso_enable = 1;
 
+	nb_segments = 0;
+	for (i = 0; i < nb_rx; ++i) {
+		m = pkts_burst[i];
+		if (!(m->ol_flags & PKT_TX_UDP_SEG)) {
+			ufo_segments[nb_segments++] = m;
+			continue;
+		}
+
+		ret = fragment(m, &ufo_segments[nb_segments],
+				RTE_DIM(ufo_segments) - nb_segments);
+		if (ret <= 0) {
+			printf("ip frag failed %s\n", strerror(-ret));
+			rte_pktmbuf_free(m);
+			continue;
+		}
+		nb_segments += ret;
+		/* free the original packet */
+		rte_pktmbuf_free(m);
+	}
+
+	nb_rx = RTE_MIN(nb_segments, MAX_PKT_BURST);
+	for (i = 0; i < nb_rx; i++)
+		pkts_burst[i] = ufo_segments[i];
+	for (i = nb_rx; i < nb_segments; ++i)
+		rte_pktmbuf_free(ufo_segments[i]);
+
 	for (i = 0; i < nb_rx; i++) {
 		if (likely(i < nb_rx - 1))
 			rte_prefetch0(rte_pktmbuf_mtod(pkts_burst[i + 1],
@@ -832,6 +929,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 		}
 	}
 
+	nb_segments = 0;
 	if (unlikely(gro_enable)) {
 		if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) {
 			nb_rx = rte_gro_reassemble_burst(pkts_burst, nb_rx,
-- 
2.7.4