Skip to contentSkip to conversation

gro: add UDP GRO and VXLAN UDP GRO support

PATCH Superseded [email protected] 3 participants 13 messages Sep 10, 2020 – Sep 17, 2020 2 messages not in the archive Arm/Amlogic Meson SoC support

v5 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v5 cover gro: add UDP GRO and VXLAN UDP GRO support

From: Yi Yang <[email protected]>

In case that UFO or GSO is enabled, GRO is very necessary, especially for UDP, it is more so. Many NICs can't support VXLAN UDP UFO/USO and VLAN UFO/USO, so UDP performance improvement depends on GSO and GRO to a great extent.

This patch series added VLAN UDP GRO and VXLAN UDP GRO support.

I have tested it in OVS DPDK, test scenario is as below:

+-------------------------+   +--------------------------+
|VM1 --- OVS DPDK --- NIC1|---| NIC2 --- OVS-DPDK --- VM2|
+-------------------------+   +--------------------------+
         SERVER1                       SERVER2

If no GSO and GRO, 8k UDP packet can't work in case of UFO or in case that underlay MTU is 1500, so UDP size must meet MTU limitation, my VM MTU is 1450 (consider vxlan header), UDP performance is about 3Gbps, with GSO and GRO enabled, I can send 8K UDP packet, UDP performance is about 6Gbps (Note: with small UDP packet loss rate).

FYI: OVS DPDK patch series
https://patchwork.ozlabs.org/project/openvswitch/list/?series=194621

Changelog
---------
v4 -> v5: remove duplicate line
fix header length check issue
add unlikely for some low probability condition branch rename udp_check_neighbor to udp4_check_neighbor remove brace for single line else statement remove outer_l2_len and pkt->outer_l3_len because they
are nonsense for non-VXLAN UDP packet

v3 -> v4: split two patches in cleaner way
remove ip_id which is unnecessary for UDP GRO correct hdr_len calculation

v2 -> v3: remove UDP header length check

v1 -> v2: split into two patches

Yi Yang (2):
gro: add UDP GRO support
gro: add VXLAN UDP GRO support

 lib/librte_gro/gro_udp4.c       | 430 +++++++++++++++++++++++++++++++
 lib/librte_gro/gro_udp4.h       | 282 +++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 192 +++++++++++---
 lib/librte_gro/rte_gro.h        |   8 +-
 7 files changed, 1580 insertions(+), 34 deletions(-)
 create mode 100644 lib/librte_gro/gro_udp4.c
 create mode 100644 lib/librte_gro/gro_udp4.h
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
Signature · 1 line
1.8.3.1
#1 lore raw

PATCH v5 1/2 gro: add UDP GRO support

From: Yi Yang <[email protected]>

UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VLAN TSO case.

---
 lib/librte_gro/gro_udp4.c  | 430 +++++++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_udp4.h  | 281 +++++++++++++++++++++++++++++
 lib/librte_gro/meson.build |   2 +-
 lib/librte_gro/rte_gro.c   |  93 ++++++++--
 lib/librte_gro/rte_gro.h   |   5 +-
 5 files changed, 795 insertions(+), 16 deletions(-)
 create mode 100644 lib/librte_gro/gro_udp4.c
 create mode 100644 lib/librte_gro/gro_udp4.h
lib/librte_gro/gro_udp4.c new file +430 -0
new file mode 100644
index 0000000..061e7b0
@@ -0,0 +1,430 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#include <rte_malloc.h>
+#include <rte_mbuf.h>
+#include <rte_cycles.h>
+#include <rte_ethdev.h>
+
+#include "gro_udp4.h"
+
+void *
+gro_udp4_tbl_create(uint16_t socket_id,
+		uint16_t max_flow_num,
+		uint16_t max_item_per_flow)
+{
+	struct gro_udp4_tbl *tbl;
+	size_t size;
+	uint32_t entries_num, i;
+
+	entries_num = max_flow_num * max_item_per_flow;
+	entries_num = RTE_MIN(entries_num, GRO_UDP4_TBL_MAX_ITEM_NUM);
+
+	if (entries_num == 0)
+		return NULL;
+
+	tbl = rte_zmalloc_socket(__func__,
+			sizeof(struct gro_udp4_tbl),
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl == NULL)
+		return NULL;
+
+	size = sizeof(struct gro_udp4_item) * entries_num;
+	tbl->items = rte_zmalloc_socket(__func__,
+			size,
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl->items == NULL) {
+		rte_free(tbl);
+		return NULL;
+	}
+	tbl->max_item_num = entries_num;
+
+	size = sizeof(struct gro_udp4_flow) * entries_num;
+	tbl->flows = rte_zmalloc_socket(__func__,
+			size,
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl->flows == NULL) {
+		rte_free(tbl->items);
+		rte_free(tbl);
+		return NULL;
+	}
+	/* INVALID_ARRAY_INDEX indicates an empty flow */
+	for (i = 0; i < entries_num; i++)
+		tbl->flows[i].start_index = INVALID_ARRAY_INDEX;
+	tbl->max_flow_num = entries_num;
+
+	return tbl;
+}
+
+void
+gro_udp4_tbl_destroy(void *tbl)
+{
+	struct gro_udp4_tbl *udp_tbl = tbl;
+
+	if (udp_tbl) {
+		rte_free(udp_tbl->items);
+		rte_free(udp_tbl->flows);
+	}
+	rte_free(udp_tbl);
+}
+
+static inline uint32_t
+find_an_empty_item(struct gro_udp4_tbl *tbl)
+{
+	uint32_t i;
+	uint32_t max_item_num = tbl->max_item_num;
+
+	for (i = 0; i < max_item_num; i++)
+		if (tbl->items[i].firstseg == NULL)
+			return i;
+	return INVALID_ARRAY_INDEX;
+}
+
+static inline uint32_t
+find_an_empty_flow(struct gro_udp4_tbl *tbl)
+{
+	uint32_t i;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++)
+		if (tbl->flows[i].start_index == INVALID_ARRAY_INDEX)
+			return i;
+	return INVALID_ARRAY_INDEX;
+}
+
+static inline uint32_t
+insert_new_item(struct gro_udp4_tbl *tbl,
+		struct rte_mbuf *pkt,
+		uint64_t start_time,
+		uint32_t prev_idx,
+		uint16_t frag_offset,
+		uint8_t is_last_frag)
+{
+	uint32_t item_idx;
+
+	item_idx = find_an_empty_item(tbl);
+	if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+		return INVALID_ARRAY_INDEX;
+
+	tbl->items[item_idx].firstseg = pkt;
+	tbl->items[item_idx].lastseg = rte_pktmbuf_lastseg(pkt);
+	tbl->items[item_idx].start_time = start_time;
+	tbl->items[item_idx].next_pkt_idx = INVALID_ARRAY_INDEX;
+	tbl->items[item_idx].frag_offset = frag_offset;
+	tbl->items[item_idx].is_last_frag = is_last_frag;
+	tbl->items[item_idx].nb_merged = 1;
+	tbl->item_num++;
+
+	/* if the previous packet exists, chain them together. */
+	if (prev_idx != INVALID_ARRAY_INDEX) {
+		tbl->items[item_idx].next_pkt_idx =
+			tbl->items[prev_idx].next_pkt_idx;
+		tbl->items[prev_idx].next_pkt_idx = item_idx;
+	}
+
+	return item_idx;
+}
+
+static inline uint32_t
+delete_item(struct gro_udp4_tbl *tbl, uint32_t item_idx,
+		uint32_t prev_item_idx)
+{
+	uint32_t next_idx = tbl->items[item_idx].next_pkt_idx;
+
+	/* NULL indicates an empty item */
+	tbl->items[item_idx].firstseg = NULL;
+	tbl->item_num--;
+	if (prev_item_idx != INVALID_ARRAY_INDEX)
+		tbl->items[prev_item_idx].next_pkt_idx = next_idx;
+
+	return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_udp4_tbl *tbl,
+		struct udp4_flow_key *src,
+		uint32_t item_idx)
+{
+	struct udp4_flow_key *dst;
+	uint32_t flow_idx;
+
+	flow_idx = find_an_empty_flow(tbl);
+	if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+		return INVALID_ARRAY_INDEX;
+
+	dst = &(tbl->flows[flow_idx].key);
+
+	rte_ether_addr_copy(&(src->eth_saddr), &(dst->eth_saddr));
+	rte_ether_addr_copy(&(src->eth_daddr), &(dst->eth_daddr));
+	dst->ip_src_addr = src->ip_src_addr;
+	dst->ip_dst_addr = src->ip_dst_addr;
+	dst->ip_id = src->ip_id;
+
+	tbl->flows[flow_idx].start_index = item_idx;
+	tbl->flow_num++;
+
+	return flow_idx;
+}
+
+/*
+ * update the packet length for the flushed packet.
+ */
+static inline void
+update_header(struct gro_udp4_item *item)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_mbuf *pkt = item->firstseg;
+	uint16_t frag_offset;
+
+	ipv4_hdr = (struct rte_ipv4_hdr *)(rte_pktmbuf_mtod(pkt, char *) +
+			pkt->l2_len);
+	ipv4_hdr->total_length = rte_cpu_to_be_16(pkt->pkt_len -
+			pkt->l2_len);
+
+	/* Clear MF bit if it is last fragment */
+	if (item->is_last_frag) {
+		frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset);
+		ipv4_hdr->fragment_offset =
+			rte_cpu_to_be_16(frag_offset & ~RTE_IPV4_HDR_MF_FLAG);
+	}
+}
+
+int32_t
+gro_udp4_reassemble(struct rte_mbuf *pkt,
+		struct gro_udp4_tbl *tbl,
+		uint64_t start_time)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_ipv4_hdr *ipv4_hdr;
+	uint16_t ip_dl;
+	uint16_t ip_id, hdr_len;
+	uint16_t frag_offset = 0;
+	uint8_t is_last_frag;
+
+	struct udp4_flow_key key;
+	uint32_t cur_idx, prev_idx, item_idx;
+	uint32_t i, max_flow_num, remaining_flow_num;
+	int cmp;
+	uint8_t find;
+
+	eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	ipv4_hdr = (struct rte_ipv4_hdr *)((char *)eth_hdr + pkt->l2_len);
+	hdr_len = pkt->l2_len + pkt->l3_len;
+
+	/*
+	 * Don't process non-fragment packet.
+	 */
+	if (!is_ipv4_fragment(ipv4_hdr))
+		return -1;
+
+	/*
+	 * Don't process the packet whose payload length is less than or
+	 * equal to 0.
+	 */
+	if (pkt->pkt_len <= hdr_len)
+		return -1;
+
+	ip_dl = rte_be_to_cpu_16(ipv4_hdr->total_length);
+	if (ip_dl <= pkt->l3_len)
+		return -1;
+
+	ip_dl -= pkt->l3_len;
+	ip_id = rte_be_to_cpu_16(ipv4_hdr->packet_id);
+	frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset);
+	is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0;
+	frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3;
+
+	rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr));
+	rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr));
+	key.ip_src_addr = ipv4_hdr->src_addr;
+	key.ip_dst_addr = ipv4_hdr->dst_addr;
+	key.ip_id = ip_id;
+
+	/* Search for a matched flow. */
+	max_flow_num = tbl->max_flow_num;
+	remaining_flow_num = tbl->flow_num;
+	find = 0;
+	for (i = 0; i < max_flow_num && remaining_flow_num; i++) {
+		if (tbl->flows[i].start_index != INVALID_ARRAY_INDEX) {
+			if (is_same_udp4_flow(tbl->flows[i].key, key)) {
+				find = 1;
+				break;
+			}
+			remaining_flow_num--;
+		}
+	}
+
+	/*
+	 * Fail to find a matched flow. Insert a new flow and store the
+	 * packet into the flow.
+	 */
+	if (find == 0) {
+		item_idx = insert_new_item(tbl, pkt, start_time,
+				INVALID_ARRAY_INDEX, frag_offset,
+				is_last_frag);
+		if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+			return -1;
+		if (insert_new_flow(tbl, &key, item_idx) ==
+				INVALID_ARRAY_INDEX) {
+			/*
+			 * Fail to insert a new flow, so delete the
+			 * stored packet.
+			 */
+			delete_item(tbl, item_idx, INVALID_ARRAY_INDEX);
+			return -1;
+		}
+		return 0;
+	}
+
+	/*
+	 * Check all packets in the flow and try to find a neighbor for
+	 * the input packet.
+	 */
+	cur_idx = tbl->flows[i].start_index;
+	prev_idx = cur_idx;
+	do {
+		cmp = udp4_check_neighbor(&(tbl->items[cur_idx]),
+				frag_offset, ip_dl, 0);
+		if (cmp) {
+			if (merge_two_udp4_packets(&(tbl->items[cur_idx]),
+						pkt, cmp, frag_offset,
+						is_last_frag, 0))
+				return 1;
+			/*
+			 * Fail to merge the two packets, as the packet
+			 * length is greater than the max value. Store
+			 * the packet into the flow.
+			 */
+			if (insert_new_item(tbl, pkt, start_time, prev_idx,
+						frag_offset, is_last_frag) ==
+					INVALID_ARRAY_INDEX)
+				return -1;
+			return 0;
+		}
+
+		/* Ensure inserted items are ordered by frag_offset */
+		if (frag_offset
+			< tbl->items[cur_idx].frag_offset) {
+			break;
+		}
+
+		prev_idx = cur_idx;
+		cur_idx = tbl->items[cur_idx].next_pkt_idx;
+	} while (cur_idx != INVALID_ARRAY_INDEX);
+
+	/* Fail to find a neighbor, so store the packet into the flow. */
+	if (cur_idx == tbl->flows[i].start_index) {
+		/* Insert it before the first packet of the flow */
+		item_idx = insert_new_item(tbl, pkt, start_time,
+				INVALID_ARRAY_INDEX, frag_offset,
+				is_last_frag);
+		if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+			return -1;
+		tbl->items[item_idx].next_pkt_idx = cur_idx;
+		tbl->flows[i].start_index = item_idx;
+	} else {
+		if (insert_new_item(tbl, pkt, start_time, prev_idx,
+				frag_offset, is_last_frag)
+			== INVALID_ARRAY_INDEX)
+			return -1;
+	}
+
+	return 0;
+}
+
+static int
+gro_udp4_merge_items(struct gro_udp4_tbl *tbl,
+			   uint32_t start_idx)
+{
+	uint16_t frag_offset;
+	uint8_t is_last_frag;
+	int16_t ip_dl;
+	struct rte_mbuf *pkt;
+	int cmp;
+	uint32_t item_idx;
+	uint16_t hdr_len;
+
+	item_idx = tbl->items[start_idx].next_pkt_idx;
+	while (item_idx != INVALID_ARRAY_INDEX) {
+		pkt = tbl->items[item_idx].firstseg;
+		hdr_len = pkt->l2_len + pkt->l3_len;
+		ip_dl = pkt->pkt_len - hdr_len;
+		frag_offset = tbl->items[item_idx].frag_offset;
+		is_last_frag = tbl->items[item_idx].is_last_frag;
+		cmp = udp4_check_neighbor(&(tbl->items[start_idx]),
+					frag_offset, ip_dl, 0);
+		if (cmp) {
+			if (merge_two_udp4_packets(
+					&(tbl->items[start_idx]),
+					pkt, cmp, frag_offset,
+					is_last_frag, 0)) {
+				item_idx = delete_item(tbl, item_idx,
+							INVALID_ARRAY_INDEX);
+				tbl->items[start_idx].next_pkt_idx
+					= item_idx;
+			} else
+				return 0;
+		} else
+			return 0;
+	}
+
+	return 0;
+}
+
+uint16_t
+gro_udp4_tbl_timeout_flush(struct gro_udp4_tbl *tbl,
+		uint64_t flush_timestamp,
+		struct rte_mbuf **out,
+		uint16_t nb_out)
+{
+	uint16_t k = 0;
+	uint32_t i, j;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++) {
+		if (unlikely(tbl->flow_num == 0))
+			return k;
+
+		j = tbl->flows[i].start_index;
+		while (j != INVALID_ARRAY_INDEX) {
+			if (tbl->items[j].start_time <= flush_timestamp) {
+				gro_udp4_merge_items(tbl, j);
+				out[k++] = tbl->items[j].firstseg;
+				if (tbl->items[j].nb_merged > 1)
+					update_header(&(tbl->items[j]));
+				/*
+				 * Delete the packet and get the next
+				 * packet in the flow.
+				 */
+				j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+				tbl->flows[i].start_index = j;
+				if (j == INVALID_ARRAY_INDEX)
+					tbl->flow_num--;
+
+				if (unlikely(k == nb_out))
+					return k;
+			} else
+				/*
+				 * The left packets in this flow won't be
+				 * timeout. Go to check other flows.
+				 */
+				break;
+		}
+	}
+	return k;
+}
+
+uint32_t
+gro_udp4_tbl_pkt_count(void *tbl)
+{
+	struct gro_udp4_tbl *gro_tbl = tbl;
+
+	if (gro_tbl)
+		return gro_tbl->item_num;
+
+	return 0;
+}
lib/librte_gro/gro_udp4.h new file +281 -0

281 lines not on this page · raw message

lib/librte_gro/meson.build +1 -1
index 501668c..0d18dc2 100644
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright(c) 2017 Intel Corporation
 
-sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_vxlan_tcp4.c')
+sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c')
 headers = files('rte_gro.h')
 deps += ['ethdev']
lib/librte_gro/rte_gro.c +79 -14

217 lines not on this page · raw message

lib/librte_gro/rte_gro.h +4 -1
index 8d781b5..470f3ed 100644
@@ -31,7 +31,10 @@
 /**< TCP/IPv4 GRO flag */
 #define RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX 1
 #define RTE_GRO_IPV4_VXLAN_TCP_IPV4 (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX)
-/**< VxLAN GRO flag. */
+/**< VxLAN TCP/IPv4 GRO flag. */
+#define RTE_GRO_UDP_IPV4_INDEX 2
+#define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
+/**< UDP/IPv4 GRO flag */
 
 /**
  * Structure used to create GRO context objects or used to pass
Signature · 1 line
1.8.3.1
#2 lore raw

PATCH v5 2/2 gro: add VXLAN UDP GRO support

In reply to [email protected]

From: Yi Yang <[email protected]>

VXLAN UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VXLAN TSO case.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +548 -0

548 lines not on this page · raw message

lib/librte_gro/gro_vxlan_udp4.h new file +152 -0

152 lines not on this page · raw message

lib/librte_gro/meson.build +1 -1
index 0d18dc2..ea8b45c 100644
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright(c) 2017 Intel Corporation
 
-sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c')
+sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c')
 headers = files('rte_gro.h')
 deps += ['ethdev']
lib/librte_gro/rte_gro.c +89 -26

208 lines not on this page · raw message

lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**
  * Structure used to create GRO context objects or used to pass
Signature · 1 line
1.8.3.1

A message that is not in the archive (sent off-list or not yet received): 20200911042416.GA46174@NPG_DPDK_VIRTIO_jiayuhu_15.sh.intel.com

A message that is not in the archive (sent off-list or not yet received): [email protected]

#5 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Replies are inline.

BTW, you need to update the programmer guide doc/guides/prog_guide/generic_receive_offload_lib.rst and release note doc/guides/rel_notes/release_20_11.rst.

Thanks,
Jiayu

Quoted 295 lines · yang_y_yi

Jiayu, thank you so much, please check my replies for some of your comments, here is incremental patch. I built it by meson this time :-)

lib/librte_gro/gro_vxlan_udp4.c +5 -5
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
lib/librte_gro/gro_vxlan_udp4.c +8 -10
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
                frag_offset = tbl->items[item_idx].inner_item.frag_offset;
                is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),
                                        frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -481,12 +481,10 @@
                                                        INVALID_ARRAY_INDEX);
                                tbl->items[start_idx].inner_item.next_pkt_idx
                                        = item_idx;
-                       } else {
+                       } else
                                return 0;
-                       }
-               } else {
+               } else
                        return 0;
-               }
        }
 
        return 0;
Quoted 108 lines · Jiayu Hu

Some comments are inline.

Thanks,
Jiayu

Quoted 102 lines · On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

From: Yi Yang <[email protected]>

VXLAN UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VXLAN TSO case.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +59 -0
new file mode 100644
index 0000000..9e9df72
@@ -0,0 +1,548 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+
+
+static inline uint32_t
+delete_item(struct gro_vxlan_udp4_tbl *tbl,
+            uint32_t item_idx,
+            uint32_t prev_item_idx)
+{
+    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;
+
+    /* NULL indicates an empty item. */
+    tbl->items[item_idx].inner_item.firstseg = NULL;
+    tbl->item_num--;
+    if (prev_item_idx != INVALID_ARRAY_INDEX)
+            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;
+
+    return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,
+            struct vxlan_udp4_flow_key *src,
+            uint32_t item_idx)
+{
+    struct vxlan_udp4_flow_key *dst;
+    uint32_t flow_idx;
+
+    flow_idx = find_an_empty_flow(tbl);
+    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+            return INVALID_ARRAY_INDEX;
+
+    dst = &(tbl->flows[flow_idx].key);
+
+    rte_ether_addr_copy(&(src->inner_key.eth_saddr),
+                    &(dst->inner_key.eth_saddr));
+    rte_ether_addr_copy(&(src->inner_key.eth_daddr),
+                    &(dst->inner_key.eth_daddr));
+    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;
+    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;
+    dst->inner_key.ip_id = src->inner_key.ip_id;
+
+    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;
+    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;
+    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));
+    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));
+    dst->outer_ip_src_addr = src->outer_ip_src_addr;
+    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;
+    dst->outer_src_port = src->outer_src_port;
+    dst->outer_dst_port = src->outer_dst_port;
+
+    tbl->flows[flow_idx].start_index = item_idx;
+    tbl->flow_num++;
+
+    return flow_idx;
+}
+
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 192

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+static inline int
+is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
+            struct vxlan_udp4_flow_key k2)
+{
+    /* src port is changing, so shouldn't use it for flow check */

As I know, fragments of a vxlan/udp/ipv4 packet have same outer source port. In what cases outer source port will change?

In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port, protocol type).

ovs/lib/netdev-native-tnl.h:

static inline uint32_t *
dp_packet_rss_ptr(const struct dp_packet *b)

{
    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);
}

static inline uint32_t
dp_packet_get_rss_hash(const struct dp_packet *p)

{
    return *dp_packet_rss_ptr(p);
}

static inline ovs_be16
netdev_tnl_get_src_port(struct dp_packet *packet)

{
    uint32_t hash;

    hash = dp_packet_get_rss_hash(packet);

    return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +
                 tnl_udp_port_min);
}

void
netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,
struct dp_packet *packet, const struct ovs_action_push_tnl *data)

{
    struct udp_header *udp;
    int ip_tot_size;

    udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    /* set udp src port */
    udp->udp_src = netdev_tnl_get_src_port(packet);
    udp->udp_len = htons(ip_tot_size);

    if (udp->udp_csum) {
        netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);
    }
}
Quoted 5 lines

This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The first fragment of original inner UDP is considered as different flow from other fragments.

I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

You are right. I checked VxLAN RFC 7348, and outer source port is calculated from inner packet. In OVS case, the first fragment will have different outer source port compared with other fragments. Please add some comments in the code for people to better understand the code. In addition, need to remove outer_src_port from the structure vxlan_udp4_flow_key.

Quoted 37 lines
Quoted 11 lines
Quoted 11 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
+                                    &k2.outer_eth_saddr) &&
+                    rte_is_same_ether_addr(&k1.outer_eth_daddr,
+                            &k2.outer_eth_daddr) &&
+                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&
+                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&
+                    (k1.outer_dst_port == k2.outer_dst_port) &&
+                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&
+                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&
+                    is_same_udp4_flow(k1.inner_key, k2.inner_key));
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 208

Quoted 6 lines
lib/librte_gro/gro_vxlan_udp4.c new file +6 -0
+}
+
+static inline int
+udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+            uint16_t frag_offset,
+            uint16_t ip_dl)

Better rename it as udp4_check_vxlan_neighbor.

Ok

Quoted 14 lines

lib/librte_gro/gro_vxlan_udp4.c line 217

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +9 -0
+{
+    struct rte_mbuf *pkt = item->inner_item.firstseg;
+    int cmp;
+    uint16_t l2_offset;
+    int ret = 0;
+
+    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
+    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+                                    l2_offset);

Why don't check outer IP ID? If outer DF bit is not set, all fragments should have incremental outer IP ID; if DF bit is set, we don't need to check outer IP ID.

Quoted 2 lines

By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check is enough to differentiate if they are same flow, isn't it?

OVS is one of workloads using DPDK, and we can assume other cases have the same design as OVS. I think IP ID check is necessary.

Quoted 197 lines
Quoted 3 lines

In addition, udp_check_neighbor is renamed, but you didn't change here.

Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will use meson build to check it for next version.

Quoted 181 lines
Quoted 181 lines
lib/librte_gro/gro_vxlan_udp4.c new file +81 -23
+    /* VXLAN outer IP ID is out of order, so don't touch it and
+     * don't compare it.
+     */
+    if (cmp > 0)
+            /* Append the new packet. */
+            ret = 1;
+    else if (cmp < 0)
+            /* Prepend the new packet. */
+            ret = -1;
+
+    return ret;
+}
+
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+                    = {{{0}, 0, 0} };
+
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
                     = {{{0}, 0, 0} };
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
 
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];
 
     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;
-    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;
+    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,
                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c struct gro_ctx { · line 404

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;

Don't need to calculate left_nb_out here. In the previous patch, you also calculate it for UDP GRO. Please remove it both.

Quoted 1 line

I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

I don't think so. It's unnecessary for current design. If others want to add new GRO types, they will write correct code.

Quoted 7 lines
Quoted 2 lines
author
#6 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Thanks Jiayu, will change them per your comments. For doument part, is such change ok?

doc/guides/prog_guide/generic_receive_offload_lib.rst +3 -3
index 5b3fb91..98a5d29 100644
@@ -30,9 +30,9 @@ assumes the packets are complete (i.e., MF==0 && frag_off==0), whe
 fragmentation is possible (i.e., DF==0). Additionally, it complies RFC
 6864 to process the IPv4 ID field.
 
-Currently, the GRO library provides GRO supports for TCP/IPv4 packets and
-VxLAN packets which contain an outer IPv4 header and an inner TCP/IPv4
-packet.
+Currently, the GRO library provides GRO supports for TCP/IPv4 and UDP/IPv4
+packets as well as VxLAN packets which contain an outer IPv4 header and an
+inner TCP/IPv4 or UDP/IPv4 packet.
 
 Two Sets of API
 ---------------
doc/guides/rel_notes/release_20_11.rst +6 -0
index df227a1..25e0387 100644
@@ -55,6 +55,12 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Add UDP/IPv4 GRO support for VxLAN and non-VxLAN packets.**
+
+  Add UDP/IPv4 GRO support for VxLAN and non-VxLAN packets. For
+  VxLAN packets, this adds inner UDP/IPv4 support, for non-VxLAN
+  packets, this adds UDP/IPv4 support.
+
 
 Removed Items
 -------------
Quoted 572 lines · Jiayu Hu

Replies are inline.

BTW, you need to update the programmer guide doc/guides/prog_guide/generic_receive_offload_lib.rst and release note doc/guides/rel_notes/release_20_11.rst.

Thanks,
Jiayu

Quoted 295 lines · yang_y_yi

Jiayu, thank you so much, please check my replies for some of your comments, here is incremental patch. I built it by meson this time :-)

lib/librte_gro/gro_vxlan_udp4.c +5 -5
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
lib/librte_gro/gro_vxlan_udp4.c +8 -10
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
                frag_offset = tbl->items[item_idx].inner_item.frag_offset;
                is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),
                                        frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -481,12 +481,10 @@
                                                        INVALID_ARRAY_INDEX);
                                tbl->items[start_idx].inner_item.next_pkt_idx
                                        = item_idx;
-                       } else {
+                       } else
                                return 0;
-                       }
-               } else {
+               } else
                        return 0;
-               }
        }
 
        return 0;
Quoted 108 lines · Jiayu Hu

Some comments are inline.

Thanks,
Jiayu

Quoted 102 lines · On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

From: Yi Yang <[email protected]>

VXLAN UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VXLAN TSO case.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +59 -0
new file mode 100644
index 0000000..9e9df72
@@ -0,0 +1,548 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+
+
+static inline uint32_t
+delete_item(struct gro_vxlan_udp4_tbl *tbl,
+            uint32_t item_idx,
+            uint32_t prev_item_idx)
+{
+    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;
+
+    /* NULL indicates an empty item. */
+    tbl->items[item_idx].inner_item.firstseg = NULL;
+    tbl->item_num--;
+    if (prev_item_idx != INVALID_ARRAY_INDEX)
+            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;
+
+    return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,
+            struct vxlan_udp4_flow_key *src,
+            uint32_t item_idx)
+{
+    struct vxlan_udp4_flow_key *dst;
+    uint32_t flow_idx;
+
+    flow_idx = find_an_empty_flow(tbl);
+    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+            return INVALID_ARRAY_INDEX;
+
+    dst = &(tbl->flows[flow_idx].key);
+
+    rte_ether_addr_copy(&(src->inner_key.eth_saddr),
+                    &(dst->inner_key.eth_saddr));
+    rte_ether_addr_copy(&(src->inner_key.eth_daddr),
+                    &(dst->inner_key.eth_daddr));
+    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;
+    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;
+    dst->inner_key.ip_id = src->inner_key.ip_id;
+
+    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;
+    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;
+    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));
+    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));
+    dst->outer_ip_src_addr = src->outer_ip_src_addr;
+    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;
+    dst->outer_src_port = src->outer_src_port;
+    dst->outer_dst_port = src->outer_dst_port;
+
+    tbl->flows[flow_idx].start_index = item_idx;
+    tbl->flow_num++;
+
+    return flow_idx;
+}
+
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 64

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+static inline int
+is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
+            struct vxlan_udp4_flow_key k2)
+{
+    /* src port is changing, so shouldn't use it for flow check */

As I know, fragments of a vxlan/udp/ipv4 packet have same outer source port. In what cases outer source port will change?

In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port, protocol type).

ovs/lib/netdev-native-tnl.h:

static inline uint32_t *
dp_packet_rss_ptr(const struct dp_packet *b)

{
    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);
}

static inline uint32_t
dp_packet_get_rss_hash(const struct dp_packet *p)

{
    return *dp_packet_rss_ptr(p);
}

static inline ovs_be16
netdev_tnl_get_src_port(struct dp_packet *packet)

{
    uint32_t hash;

    hash = dp_packet_get_rss_hash(packet);

    return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +
                 tnl_udp_port_min);
}

void
netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,
struct dp_packet *packet, const struct ovs_action_push_tnl *data)

{
    struct udp_header *udp;
    int ip_tot_size;

    udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    /* set udp src port */
    udp->udp_src = netdev_tnl_get_src_port(packet);
    udp->udp_len = htons(ip_tot_size);

    if (udp->udp_csum) {
        netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);
    }
}
Quoted 5 lines

This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The first fragment of original inner UDP is considered as different flow from other fragments.

I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

You are right. I checked VxLAN RFC 7348, and outer source port is calculated from inner packet. In OVS case, the first fragment will have different outer source port compared with other fragments. Please add some comments in the code for people to better understand the code. In addition, need to remove outer_src_port from the structure vxlan_udp4_flow_key.

Quoted 37 lines
Quoted 11 lines
Quoted 11 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
+                                    &k2.outer_eth_saddr) &&
+                    rte_is_same_ether_addr(&k1.outer_eth_daddr,
+                            &k2.outer_eth_daddr) &&
+                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&
+                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&
+                    (k1.outer_dst_port == k2.outer_dst_port) &&
+                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&
+                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&
+                    is_same_udp4_flow(k1.inner_key, k2.inner_key));
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 80

Quoted 6 lines
lib/librte_gro/gro_vxlan_udp4.c new file +6 -0
+}
+
+static inline int
+udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+            uint16_t frag_offset,
+            uint16_t ip_dl)

Better rename it as udp4_check_vxlan_neighbor.

Ok

Quoted 14 lines

lib/librte_gro/gro_vxlan_udp4.c line 89

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +9 -0
+{
+    struct rte_mbuf *pkt = item->inner_item.firstseg;
+    int cmp;
+    uint16_t l2_offset;
+    int ret = 0;
+
+    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
+    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+                                    l2_offset);

Why don't check outer IP ID? If outer DF bit is not set, all fragments should have incremental outer IP ID; if DF bit is set, we don't need to check outer IP ID.

Quoted 2 lines

By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check is enough to differentiate if they are same flow, isn't it?

OVS is one of workloads using DPDK, and we can assume other cases have the same design as OVS. I think IP ID check is necessary.

Quoted 197 lines
Quoted 3 lines

In addition, udp_check_neighbor is renamed, but you didn't change here.

Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will use meson build to check it for next version.

Quoted 181 lines
Quoted 181 lines
lib/librte_gro/gro_vxlan_udp4.c new file +81 -23
+    /* VXLAN outer IP ID is out of order, so don't touch it and
+     * don't compare it.
+     */
+    if (cmp > 0)
+            /* Append the new packet. */
+            ret = 1;
+    else if (cmp < 0)
+            /* Prepend the new packet. */
+            ret = -1;
+
+    return ret;
+}
+
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+                    = {{{0}, 0, 0} };
+
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
                     = {{{0}, 0, 0} };
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
 
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];
 
     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;
-    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;
+    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,
                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c struct gro_ctx { · line 404

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;

Don't need to calculate left_nb_out here. In the previous patch, you also calculate it for UDP GRO. Please remove it both.

Quoted 1 line

I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

I don't think so. It's unnecessary for current design. If others want to add new GRO types, they will write correct code.

Quoted 7 lines
Quoted 2 lines
author
#7 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

In reply to Jiayu Hu

For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so we can't use ip_id +/-1 to check if they are same flow, here is my incrmental change for it with more comments.

@@ -189,7 +188,12 @@
is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
struct vxlan_udp4_flow_key k2)
{
- /* src port is changing, so shouldn't use it for flow check */
+ /* For VxLAN packet, outer udp src port is calculated from

+        * inner packet RSS hash, udp src port of the first UDP
+        * fragment is different from one of other UDP fragments
+        * even if they are same flow, so we have to skip outer udp
+        * src port comparison here.
+        */
        return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                        &k2.outer_eth_saddr) &&
                        rte_is_same_ether_addr(&k1.outer_eth_daddr,
@@ -212,12 +216,16 @@
        uint16_t l2_offset;
        int ret = 0;

+ /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,

+        * we needn't compare outer_ip_id because they are same,
+        * for the case outer_is_atomic is 1, we also have no way
+        * to comapre outer_ip_id because the received packets can
+        * be out of order. So ignore outer_ip_id comparison here.
+        */
+
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
        cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
-       /* VXLAN outer IP ID is out of order, so don't touch it and
-        * don't compare it.
-        */
        if (cmp > 0)
                /* Append the new packet. */
                ret = 1;
@@ -354,7 +362,9 @@
        rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr));
        key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
        key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;

- key.outer_src_port = udp_hdr->src_port;
+ /* Note: It is unnecessary to save outer_src_port here because it can
+ * be different for VxLAN UDP fragments from the same flow.
+ */

        key.outer_dst_port = udp_hdr->dst_port;

        /* Search for a matched flow. */
Quoted 572 lines · Jiayu Hu

Replies are inline.

BTW, you need to update the programmer guide doc/guides/prog_guide/generic_receive_offload_lib.rst and release note doc/guides/rel_notes/release_20_11.rst.

Thanks,
Jiayu

Quoted 295 lines · yang_y_yi

Jiayu, thank you so much, please check my replies for some of your comments, here is incremental patch. I built it by meson this time :-)

lib/librte_gro/gro_vxlan_udp4.c +5 -5
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
lib/librte_gro/gro_vxlan_udp4.c +8 -10
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
                frag_offset = tbl->items[item_idx].inner_item.frag_offset;
                is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),
                                        frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -481,12 +481,10 @@
                                                        INVALID_ARRAY_INDEX);
                                tbl->items[start_idx].inner_item.next_pkt_idx
                                        = item_idx;
-                       } else {
+                       } else
                                return 0;
-                       }
-               } else {
+               } else
                        return 0;
-               }
        }
 
        return 0;
Quoted 108 lines · Jiayu Hu

Some comments are inline.

Thanks,
Jiayu

Quoted 102 lines · On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

From: Yi Yang <[email protected]>

VXLAN UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VXLAN TSO case.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +59 -0
new file mode 100644
index 0000000..9e9df72
@@ -0,0 +1,548 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+
+
+static inline uint32_t
+delete_item(struct gro_vxlan_udp4_tbl *tbl,
+            uint32_t item_idx,
+            uint32_t prev_item_idx)
+{
+    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;
+
+    /* NULL indicates an empty item. */
+    tbl->items[item_idx].inner_item.firstseg = NULL;
+    tbl->item_num--;
+    if (prev_item_idx != INVALID_ARRAY_INDEX)
+            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;
+
+    return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,
+            struct vxlan_udp4_flow_key *src,
+            uint32_t item_idx)
+{
+    struct vxlan_udp4_flow_key *dst;
+    uint32_t flow_idx;
+
+    flow_idx = find_an_empty_flow(tbl);
+    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+            return INVALID_ARRAY_INDEX;
+
+    dst = &(tbl->flows[flow_idx].key);
+
+    rte_ether_addr_copy(&(src->inner_key.eth_saddr),
+                    &(dst->inner_key.eth_saddr));
+    rte_ether_addr_copy(&(src->inner_key.eth_daddr),
+                    &(dst->inner_key.eth_daddr));
+    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;
+    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;
+    dst->inner_key.ip_id = src->inner_key.ip_id;
+
+    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;
+    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;
+    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));
+    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));
+    dst->outer_ip_src_addr = src->outer_ip_src_addr;
+    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;
+    dst->outer_src_port = src->outer_src_port;
+    dst->outer_dst_port = src->outer_dst_port;
+
+    tbl->flows[flow_idx].start_index = item_idx;
+    tbl->flow_num++;
+
+    return flow_idx;
+}
+
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 192

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+static inline int
+is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
+            struct vxlan_udp4_flow_key k2)
+{
+    /* src port is changing, so shouldn't use it for flow check */

As I know, fragments of a vxlan/udp/ipv4 packet have same outer source port. In what cases outer source port will change?

In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port, protocol type).

ovs/lib/netdev-native-tnl.h:

static inline uint32_t *
dp_packet_rss_ptr(const struct dp_packet *b)

{
    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);
}

static inline uint32_t
dp_packet_get_rss_hash(const struct dp_packet *p)

{
    return *dp_packet_rss_ptr(p);
}

static inline ovs_be16
netdev_tnl_get_src_port(struct dp_packet *packet)

{
    uint32_t hash;

    hash = dp_packet_get_rss_hash(packet);

    return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +
                 tnl_udp_port_min);
}

void
netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,
struct dp_packet *packet, const struct ovs_action_push_tnl *data)

{
    struct udp_header *udp;
    int ip_tot_size;

    udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    /* set udp src port */
    udp->udp_src = netdev_tnl_get_src_port(packet);
    udp->udp_len = htons(ip_tot_size);

    if (udp->udp_csum) {
        netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);
    }
}
Quoted 5 lines

This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The first fragment of original inner UDP is considered as different flow from other fragments.

I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

You are right. I checked VxLAN RFC 7348, and outer source port is calculated from inner packet. In OVS case, the first fragment will have different outer source port compared with other fragments. Please add some comments in the code for people to better understand the code. In addition, need to remove outer_src_port from the structure vxlan_udp4_flow_key.

Quoted 37 lines
Quoted 11 lines
Quoted 11 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
+                                    &k2.outer_eth_saddr) &&
+                    rte_is_same_ether_addr(&k1.outer_eth_daddr,
+                            &k2.outer_eth_daddr) &&
+                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&
+                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&
+                    (k1.outer_dst_port == k2.outer_dst_port) &&
+                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&
+                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&
+                    is_same_udp4_flow(k1.inner_key, k2.inner_key));
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 208

Quoted 6 lines
lib/librte_gro/gro_vxlan_udp4.c new file +6 -0
+}
+
+static inline int
+udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+            uint16_t frag_offset,
+            uint16_t ip_dl)

Better rename it as udp4_check_vxlan_neighbor.

Ok

Quoted 14 lines

lib/librte_gro/gro_vxlan_udp4.c line 217

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +9 -0
+{
+    struct rte_mbuf *pkt = item->inner_item.firstseg;
+    int cmp;
+    uint16_t l2_offset;
+    int ret = 0;
+
+    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
+    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+                                    l2_offset);

Why don't check outer IP ID? If outer DF bit is not set, all fragments should have incremental outer IP ID; if DF bit is set, we don't need to check outer IP ID.

Quoted 2 lines

By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check is enough to differentiate if they are same flow, isn't it?

OVS is one of workloads using DPDK, and we can assume other cases have the same design as OVS. I think IP ID check is necessary.

Quoted 197 lines
Quoted 3 lines

In addition, udp_check_neighbor is renamed, but you didn't change here.

Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will use meson build to check it for next version.

Quoted 181 lines
Quoted 181 lines
lib/librte_gro/gro_vxlan_udp4.c new file +81 -23
+    /* VXLAN outer IP ID is out of order, so don't touch it and
+     * don't compare it.
+     */
+    if (cmp > 0)
+            /* Append the new packet. */
+            ret = 1;
+    else if (cmp < 0)
+            /* Prepend the new packet. */
+            ret = -1;
+
+    return ret;
+}
+
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+                    = {{{0}, 0, 0} };
+
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
                     = {{{0}, 0, 0} };
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
 
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];
 
     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;
-    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;
+    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,
                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c struct gro_ctx { · line 404

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;

Don't need to calculate left_nb_out here. In the previous patch, you also calculate it for UDP GRO. Please remove it both.

Quoted 1 line

I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

I don't think so. It's unnecessary for current design. If others want to add new GRO types, they will write correct code.

Quoted 7 lines
Quoted 2 lines
#8 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Out IP ID is not used to check if they belong to the same flow, but check if they are neighbors. If two vxlan/udp fragments are neighbors, their outer IP ID and outer frag_oft should be incremental. I still cannot understand why ignore outer IP ID when DF is 0. Can you give more explanation?

From: yang_y_yi <[email protected]>
Sent: Monday, September 14, 2020 4:27 PM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
Importance: High

For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so we can't use ip_id +/-1 to check if they are same flow, here is my incrmental change for it with more comments.

@@ -189,7 +188,12 @@
is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
struct vxlan_udp4_flow_key k2)
{
- /* src port is changing, so shouldn't use it for flow check */
+ /* For VxLAN packet, outer udp src port is calculated from

+        * inner packet RSS hash, udp src port of the first UDP
+        * fragment is different from one of other UDP fragments
+        * even if they are same flow, so we have to skip outer udp
+        * src port comparison here.
+        */
        return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                        &k2.outer_eth_saddr) &&
                        rte_is_same_ether_addr(&k1.outer_eth_daddr,
@@ -212,12 +216,16 @@
        uint16_t l2_offset;
        int ret = 0;

+ /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,

+        * we needn't compare outer_ip_id because they are same,
+        * for the case outer_is_atomic is 1, we also have no way
+        * to comapre outer_ip_id because the received packets can
+        * be out of order. So ignore outer_ip_id comparison here.
+        */
+
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
        cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
-       /* VXLAN outer IP ID is out of order, so don't touch it and
-        * don't compare it.
-        */
        if (cmp > 0)
                /* Append the new packet. */
                ret = 1;
@@ -354,7 +362,9 @@
        rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr));
        key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
        key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;

- key.outer_src_port = udp_hdr->src_port;
+ /* Note: It is unnecessary to save outer_src_port here because it can
+ * be different for VxLAN UDP fragments from the same flow.
+ */

        key.outer_dst_port = udp_hdr->dst_port;

        /* Search for a matched flow. */
Quoted 1,143 lines · At 2020-09-14 12:21:26, "Jiayu Hu" <[email protected]<mailto:[email protected]…

Replies are inline.

BTW, you need to update the programmer guide

doc/guides/prog_guide/generic_receive_offload_lib.rst and

release note doc/guides/rel_notes/release_20_11.rst.

Thanks,

Jiayu

Quoted 590 lines · yang_y_yi

Jiayu, thank you so much, please check my replies for some of your comments,

here is incremental patch. I built it by meson this time :-)

lib/librte_gro/gro_vxlan_udp4.c +0 -0

index 9e9df72..1fcfaf1 100644

--- a/lib/librte_gro/gro_vxlan_udp4.c

+++ b/lib/librte_gro/gro_vxlan_udp4.c

lib/librte_gro/gro_vxlan_udp4.c +5 -5
@@ -203,7 +203,7 @@
 
 }
 
 
 
 static inline int
 
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
 
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
 
                uint16_t frag_offset,
 
                uint16_t ip_dl)
 
 {
@@ -213,7 +213,7 @@
 
        int ret = 0;
 
 
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
 
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
 
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
 
                                        l2_offset);
 
        /* VXLAN outer IP ID is out of order, so don't touch it and
 
         * don't compare it.
@@ -379,7 +379,7 @@
 
                item_idx = insert_new_item(tbl, pkt, start_time,
 
                                INVALID_ARRAY_INDEX, frag_offset,
 
                                is_last_frag, outer_ip_id, outer_is_atomic);
 
-               if (item_idx == INVALID_ARRAY_INDEX)
 
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
 
                        return -1;
 
                if (insert_new_flow(tbl, &key, item_idx) ==
 
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
 
        cur_idx = tbl->flows[i].start_index;
 
        prev_idx = cur_idx;
 
        do {
 
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
 
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
 
                                frag_offset, ip_dl);
 
                if (cmp) {
 
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
 
                item_idx = insert_new_item(tbl, pkt, start_time,
 
                                INVALID_ARRAY_INDEX, frag_offset,
 
                                is_last_frag, outer_ip_id, outer_is_atomic);
 
-               if (item_idx == INVALID_ARRAY_INDEX)
 
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
 
                        return -1;
 
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
 
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
 
                ip_dl = pkt->pkt_len - hdr_len;
 
lib/librte_gro/gro_vxlan_udp4.c +0 -0

index 9e9df72..1fcfaf1 100644

--- a/lib/librte_gro/gro_vxlan_udp4.c

+++ b/lib/librte_gro/gro_vxlan_udp4.c

lib/librte_gro/gro_vxlan_udp4.c +8 -10
@@ -203,7 +203,7 @@
 
 }
 
 
 
 static inline int
 
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
 
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
 
                uint16_t frag_offset,
 
                uint16_t ip_dl)
 
 {
@@ -213,7 +213,7 @@
 
        int ret = 0;
 
 
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
 
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
 
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
 
                                        l2_offset);
 
        /* VXLAN outer IP ID is out of order, so don't touch it and
 
         * don't compare it.
@@ -379,7 +379,7 @@
 
                item_idx = insert_new_item(tbl, pkt, start_time,
 
                                INVALID_ARRAY_INDEX, frag_offset,
 
                                is_last_frag, outer_ip_id, outer_is_atomic);
 
-               if (item_idx == INVALID_ARRAY_INDEX)
 
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
 
                        return -1;
 
                if (insert_new_flow(tbl, &key, item_idx) ==
 
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
 
        cur_idx = tbl->flows[i].start_index;
 
        prev_idx = cur_idx;
 
        do {
 
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
 
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
 
                                frag_offset, ip_dl);
 
                if (cmp) {
 
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
 
                item_idx = insert_new_item(tbl, pkt, start_time,
 
                                INVALID_ARRAY_INDEX, frag_offset,
 
                                is_last_frag, outer_ip_id, outer_is_atomic);
 
-               if (item_idx == INVALID_ARRAY_INDEX)
 
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
 
                        return -1;
 
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
 
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
 
                ip_dl = pkt->pkt_len - hdr_len;
 
                frag_offset = tbl->items[item_idx].inner_item.frag_offset;
 
                is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;
 
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),
 
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),
 
                                        frag_offset, ip_dl);
 
                if (cmp) {
 
                        if (merge_two_vxlan_udp4_packets(
@@ -481,12 +481,10 @@
 
                                                        INVALID_ARRAY_INDEX);
 
                                tbl->items[start_idx].inner_item.next_pkt_idx
 
                                        = item_idx;
 
-                       } else {
 
+                       } else
 
                                return 0;
 
-                       }
 
-               } else {
 
+               } else
 
                        return 0;
 
-               }
 
        }
 
 
 
        return 0;
Quoted 224 lines · At 2020-09-11 12:24:16, "Jiayu Hu" <[email protected]<mailto:[email protected]…

Some comments are inline.

Thanks,

Jiayu

Quoted 211 lines · On Thu, Sep 10, 2020 at 05:29:14PM +0800…

From: Yi Yang <[email protected]<mailto:[email protected]>>

VXLAN UDP GRO can help improve VM-to-VM UDP performance

when VM is enabled UFO or GSO, GRO must be supported if

GSO or UFO is enabled, otherwise, performance gain will

be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to

improve VM-to-VM UDP performance, this will make sure

IP fragments will be reassembled once it is received

from physical NIC. It is very helpful in OVS DPDK VXLAN

TSO case.

---

 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +0 -0

index 0a078e4..d38b393 100644

--- a/lib/librte_gro/gro_udp4.h

+++ b/lib/librte_gro/gro_udp4.h

lib/librte_gro/gro_udp4.h +1 -0
@@ -7,6 +7,7 @@
 
 
 
 #include <rte_ip.h>
 
 #include <rte_udp.h>
 
+#include <rte_vxlan.h>
 
 
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c +0 -0

new file mode 100644

index 0000000..9e9df72

--- /dev/null

+++ b/lib/librte_gro/gro_vxlan_udp4.c

lib/librte_gro/gro_vxlan_udp4.c +63 -0
@@ -0,0 +1,548 @@
 
+/* SPDX-License-Identifier: BSD-3-Clause
 
+ * Copyright(c) 2020 Inspur Corporation
 
+ */
 
+
 
+
 
+
 
+static inline uint32_t
 
+delete_item(struct gro_vxlan_udp4_tbl *tbl,
 
+            uint32_t item_idx,
 
+            uint32_t prev_item_idx)
 
+{
 
+    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;
 
+
 
+    /* NULL indicates an empty item. */
 
+    tbl->items[item_idx].inner_item.firstseg = NULL;
 
+    tbl->item_num--;
 
+    if (prev_item_idx != INVALID_ARRAY_INDEX)
 
+            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;
 
+
 
+    return next_idx;
 
+}
 
+
 
+static inline uint32_t
 
+insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,
 
+            struct vxlan_udp4_flow_key *src,
 
+            uint32_t item_idx)
 
+{
 
+    struct vxlan_udp4_flow_key *dst;
 
+    uint32_t flow_idx;
 
+
 
+    flow_idx = find_an_empty_flow(tbl);
 
+    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
 
+            return INVALID_ARRAY_INDEX;
 
+
 
+    dst = &(tbl->flows[flow_idx].key);
 
+
 
+    rte_ether_addr_copy(&(src->inner_key.eth_saddr),
 
+                    &(dst->inner_key.eth_saddr));
 
+    rte_ether_addr_copy(&(src->inner_key.eth_daddr),
 
+                    &(dst->inner_key.eth_daddr));
 
+    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;
 
+    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;
 
+    dst->inner_key.ip_id = src->inner_key.ip_id;
 
+
 
+    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;
 
+    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;
 
+    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));
 
+    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));
 
+    dst->outer_ip_src_addr = src->outer_ip_src_addr;
 
+    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;
 
+    dst->outer_src_port = src->outer_src_port;
 
+    dst->outer_dst_port = src->outer_dst_port;
 
+
 
+    tbl->flows[flow_idx].start_index = item_idx;
 
+    tbl->flow_num++;
 
+
 
+    return flow_idx;
 
+}
 
+
 
+static inline int
 
+is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
 
+            struct vxlan_udp4_flow_key k2)
 
+{
Quoted 7 lines
Quoted 1 line

+ /* src port is changing, so shouldn't use it for flow check */

As I know, fragments of a vxlan/udp/ipv4 packet have same outer source

port. In what cases outer source port will change?

In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is

different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port,

protocol type).

ovs/lib/netdev-native-tnl.h:

static inline uint32_t *

dp_packet_rss_ptr(const struct dp_packet *b)

{

    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);

}

static inline uint32_t

dp_packet_get_rss_hash(const struct dp_packet *p)

{

    return *dp_packet_rss_ptr(p);

}

static inline ovs_be16

netdev_tnl_get_src_port(struct dp_packet *packet)

{

    uint32_t hash;



    hash = dp_packet_get_rss_hash(packet);



    return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +

                 tnl_udp_port_min);

}

void

netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,

struct dp_packet *packet,

const struct ovs_action_push_tnl *data)

{

    struct udp_header *udp;

    int ip_tot_size;



    udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);



    /* set udp src port */

    udp->udp_src = netdev_tnl_get_src_port(packet);

    udp->udp_len = htons(ip_tot_size);



    if (udp->udp_csum) {

        netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);

    }

}

Quoted 9 lines

This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The

first fragment of original inner UDP is considered as different flow from other fragments.

I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

You are right. I checked VxLAN RFC 7348, and outer source port is

calculated from inner packet. In OVS case, the first fragment

will have different outer source port compared with other fragments.

Please add some comments in the code for people to better understand

the code. In addition, need to remove outer_src_port from the structure

vxlan_udp4_flow_key.

Quoted 70 lines
Quoted 30 lines
Quoted 29 lines
lib/librte_gro/gro_vxlan_udp4.c +14 -0
+    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
 
+                                    &k2.outer_eth_saddr) &&
 
+                    rte_is_same_ether_addr(&k1.outer_eth_daddr,
 
+                            &k2.outer_eth_daddr) &&
 
+                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&
 
+                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&
 
+                    (k1.outer_dst_port == k2.outer_dst_port) &&
 
+                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&
 
+                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&
 
+                    is_same_udp4_flow(k1.inner_key, k2.inner_key));
 
+}
 
+
 
+static inline int
 
+udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
Quoted 7 lines

lib/librte_gro/gro_vxlan_udp4.c line 208

Quoted 3 lines
lib/librte_gro/gro_vxlan_udp4.c +2 -0
+            uint16_t frag_offset,
 
+            uint16_t ip_dl)

Better rename it as udp4_check_vxlan_neighbor.

Ok

Quoted 25 lines
Quoted 9 lines
lib/librte_gro/gro_vxlan_udp4.c +4 -0
+{
 
+    struct rte_mbuf *pkt = item->inner_item.firstseg;
 
+    int cmp;
 
+    uint16_t l2_offset;

lib/librte_gro/gro_vxlan_udp4.c line 217

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c +5 -0
 
+    int ret = 0;
 
+
 
+    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
 
+    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
 
+                                    l2_offset);

Why don't check outer IP ID? If outer DF bit is not set, all fragments

should have incremental outer IP ID; if DF bit is set, we don't need

Quoted 7 lines
Quoted 1 line

to check outer IP ID.

By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check

is enough to differentiate if they are same flow, isn't it?

OVS is one of workloads using DPDK, and we can assume

other cases have the same design as OVS. I think IP ID

check is necessary.

Quoted 388 lines
Quoted 5 lines

In addition, udp_check_neighbor is renamed, but you didn't change here.

Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will

use meson build to check it for next version.

Quoted 373 lines
Quoted 371 lines
lib/librte_gro/gro_vxlan_udp4.c +86 -23
+    /* VXLAN outer IP ID is out of order, so don't touch it and
 
+     * don't compare it.
 
+     */
 
+    if (cmp > 0)
 
+            /* Append the new packet. */
 
+            ret = 1;
 
+    else if (cmp < 0)
 
+            /* Prepend the new packet. */
 
+            ret = -1;
 
+
 
+    return ret;
 
+}
 
+
 
 
 
 /*
 
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
 
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
 
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
 
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
 
-    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
 
-    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
 
+    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
 
+    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 
+                    = {{{0}, 0, 0} };
 
+
 
+    /* Allocate a reassembly table for VXLAN UDP GRO */
 
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
 
+    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
 
+    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 
                     = {{{0}, 0, 0} };
 
 
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
 
     uint32_t item_num;
 
     int32_t ret;
 
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
 
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
 
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
 
+            do_vxlan_udp_gro = 0;
 
 
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
 
                                     RTE_GRO_TCP_IPV4 |
 
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 
                                     RTE_GRO_UDP_IPV4)) == 0))
 
             return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
 
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
 
             for (i = 0; i < item_num; i++)
 
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
 
-
 
-            vxlan_tbl.flows = vxlan_flows;
 
-            vxlan_tbl.items = vxlan_items;
 
-            vxlan_tbl.flow_num = 0;
 
-            vxlan_tbl.item_num = 0;
 
-            vxlan_tbl.max_flow_num = item_num;
 
-            vxlan_tbl.max_item_num = item_num;
 
-            do_vxlan_gro = 1;
 
+                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
 
+
 
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
 
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
 
+            vxlan_tcp_tbl.flow_num = 0;
 
+            vxlan_tcp_tbl.item_num = 0;
 
+            vxlan_tcp_tbl.max_flow_num = item_num;
 
+            vxlan_tcp_tbl.max_item_num = item_num;
 
+            do_vxlan_tcp_gro = 1;
 
+    }
 
+
 
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
 
+            for (i = 0; i < item_num; i++)
 
+                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;
 
+
 
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
 
+            vxlan_udp_tbl.items = vxlan_udp_items;
 
+            vxlan_udp_tbl.flow_num = 0;
 
+            vxlan_udp_tbl.item_num = 0;
 
+            vxlan_udp_tbl.max_flow_num = item_num;
 
+            vxlan_udp_tbl.max_item_num = item_num;
 
+            do_vxlan_udp_gro = 1;
 
     }
 
 
 
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
 
              * will be flushed from the tables.
 
              */
 
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
 
-                            do_vxlan_gro) {
 
+                            do_vxlan_tcp_gro) {
 
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
 
-                                                    &vxlan_tbl, 0);
 
+                                                    &vxlan_tcp_tbl, 0);
 
+                    if (ret > 0)
 
+                            /* Merge successfully */
 
+                            nb_after_gro--;
 
+                    else if (ret < 0)
 
+                            unprocess_pkts[unprocess_num++] = pkts[i];
 
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
 
+                            do_vxlan_udp_gro) {
 
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
 
+                                                    &vxlan_udp_tbl, 0);
 
                     if (ret > 0)
 
                             /* Merge successfully */
 
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
 
              || (unprocess_num < nb_pkts)) {
 
             i = 0;
 
             /* Flush all packets from the tables */
 
-            if (do_vxlan_gro) {
 
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
 
+            if (do_vxlan_tcp_gro) {
 
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
 
                                     0, pkts, nb_pkts);
 
             }
 
 
 
+            if (do_vxlan_udp_gro) {
 
+                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
 
+                                    0, &pkts[i], nb_pkts - i);
 
+
 
+            }
 
+
 
             if (do_tcp4_gro) {
 
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
 
                                     &pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 
 {
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
 
     struct gro_ctx *gro_ctx = ctx;
 
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
 
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
 
     uint64_t current_time;
 
     uint16_t i, unprocess_num = 0;
 
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
 
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;
 
 
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
 
                                     RTE_GRO_TCP_IPV4 |
 
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 
                                     RTE_GRO_UDP_IPV4)) == 0))
 
             return nb_pkts;
 
 
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
 
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
 
+    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
 
     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
 
+    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];
 
 
 
     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
 
             RTE_GRO_TCP_IPV4;
 
-    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
 
+    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
 
             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
 
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
 
             RTE_GRO_UDP_IPV4;
 
+    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==
 
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
 
 
     current_time = rte_rdtsc();
 
 
 
     for (i = 0; i < nb_pkts; i++) {
 
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
 
-                            do_vxlan_gro) {
 
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
 
+                            do_vxlan_tcp_gro) {
 
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
 
+                                            current_time) < 0)
 
+                            unprocess_pkts[unprocess_num++] = pkts[i];
 
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
 
+                            do_vxlan_udp_gro) {
 
+                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,
 
                                             current_time) < 0)
 
                             unprocess_pkts[unprocess_num++] = pkts[i];
 
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
@@ -341,6 +397,13 @@ struct gro_ctx {
 
             left_nb_out = max_nb_out - num;
 
     }
 
 
 
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {
 
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
 
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
 
+                            flush_timestamp, &out[num], left_nb_out);
 
+            left_nb_out = max_nb_out - num;
Quoted 7 lines
Quoted 3 lines

Don't need to calculate left_nb_out here. In the previous patch, you

also calculate it for UDP GRO. Please remove it both.

I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

I don't think so. It's unnecessary for current design.

If others want to add new GRO types, they will write

correct code.

Quoted 13 lines
Quoted 3 lines
author
#9 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Jiayu, VM to VM case for big UDP packet (say udp parload size is 8192K, but mtu 1500). VM will segment it as UDP framgments, but when ovs dpdk uses VxLan to encapsulate them, it doesn't know they are same flow, OVS DPDK has no knowldge about them, just encapsulate them as if they are not related. But on receive side on another machine, OVS DPDK will GRO them, at this point, outer IP ID is even random for every packet. For TCP, I think same issue is there, GRO just considered them as different flow and doesn't do GRO, in my opinion, we also should do GRO for such case.

在 2020-09-14 16:50:08,"Hu, Jiayu" <[email protected]> 写道:

Out IP ID is not used to check if they belong to the same flow,

but check if they are neighbors. If two vxlan/udp fragments are

neighbors, their outer IP ID and outer frag_oft should be incremental.

I still cannot understand why ignore outer IP ID when DF is 0.

Can you give more explanation?

From: yang_y_yi <[email protected]>
Sent: Monday, September 14, 2020 4:27 PM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
Importance: High

For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so we can't use ip_id +/-1 to check if they are same flow, here is my incrmental change for it with more comments.

@@ -189,7 +188,12 @@
is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
struct vxlan_udp4_flow_key k2)
{
- /* src port is changing, so shouldn't use it for flow check */
+ /* For VxLAN packet, outer udp src port is calculated from

+        * inner packet RSS hash, udp src port of the first UDP
+        * fragment is different from one of other UDP fragments
+        * even if they are same flow, so we have to skip outer udp
+        * src port comparison here.
+        */
        return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                        &k2.outer_eth_saddr) &&
                        rte_is_same_ether_addr(&k1.outer_eth_daddr,
@@ -212,12 +216,16 @@
        uint16_t l2_offset;
        int ret = 0;

+ /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,

+        * we needn't compare outer_ip_id because they are same,
+        * for the case outer_is_atomic is 1, we also have no way
+        * to comapre outer_ip_id because the received packets can
+        * be out of order. So ignore outer_ip_id comparison here.
+        */
+
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
        cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
-       /* VXLAN outer IP ID is out of order, so don't touch it and
-        * don't compare it.
-        */
        if (cmp > 0)
                /* Append the new packet. */
                ret = 1;
@@ -354,7 +362,9 @@
        rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &(key.outer_eth_daddr));
        key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
        key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;

- key.outer_src_port = udp_hdr->src_port;
+ /* Note: It is unnecessary to save outer_src_port here because it can
+ * be different for VxLAN UDP fragments from the same flow.
+ */

        key.outer_dst_port = udp_hdr->dst_port;

        /* Search for a matched flow. */
Quoted 572 lines · Jiayu Hu

Replies are inline.

BTW, you need to update the programmer guide doc/guides/prog_guide/generic_receive_offload_lib.rst and release note doc/guides/rel_notes/release_20_11.rst.

Thanks,
Jiayu

Quoted 295 lines · yang_y_yi

Jiayu, thank you so much, please check my replies for some of your comments, here is incremental patch. I built it by meson this time :-)

lib/librte_gro/gro_vxlan_udp4.c +5 -5
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
lib/librte_gro/gro_vxlan_udp4.c +8 -10
index 9e9df72..1fcfaf1 100644
@@ -203,7 +203,7 @@
 }
 
 static inline int
-udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
                uint16_t frag_offset,
                uint16_t ip_dl)
 {
@@ -213,7 +213,7 @@
        int ret = 0;
 
        l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
-       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                        l2_offset);
        /* VXLAN outer IP ID is out of order, so don't touch it and
         * don't compare it.
@@ -379,7 +379,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                if (insert_new_flow(tbl, &key, item_idx) ==
                                INVALID_ARRAY_INDEX) {
@@ -397,7 +397,7 @@
        cur_idx = tbl->flows[i].start_index;
        prev_idx = cur_idx;
        do {
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),
                                frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -436,7 +436,7 @@
                item_idx = insert_new_item(tbl, pkt, start_time,
                                INVALID_ARRAY_INDEX, frag_offset,
                                is_last_frag, outer_ip_id, outer_is_atomic);
-               if (item_idx == INVALID_ARRAY_INDEX)
+               if (unlikely(item_idx == INVALID_ARRAY_INDEX))
                        return -1;
                tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;
                tbl->flows[i].start_index = item_idx;
@@ -470,7 +470,7 @@
                ip_dl = pkt->pkt_len - hdr_len;
                frag_offset = tbl->items[item_idx].inner_item.frag_offset;
                is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;
-               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),
+               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),
                                        frag_offset, ip_dl);
                if (cmp) {
                        if (merge_two_vxlan_udp4_packets(
@@ -481,12 +481,10 @@
                                                        INVALID_ARRAY_INDEX);
                                tbl->items[start_idx].inner_item.next_pkt_idx
                                        = item_idx;
-                       } else {
+                       } else
                                return 0;
-                       }
-               } else {
+               } else
                        return 0;
-               }
        }
 
        return 0;
Quoted 108 lines · Jiayu Hu

Some comments are inline.

Thanks,
Jiayu

Quoted 102 lines · On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

From: Yi Yang <[email protected]>

VXLAN UDP GRO can help improve VM-to-VM UDP performance when VM is enabled UFO or GSO, GRO must be supported if GSO or UFO is enabled, otherwise, performance gain will be hurt.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, this will make sure IP fragments will be reassembled once it is received from physical NIC. It is very helpful in OVS DPDK VXLAN TSO case.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 794 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +59 -0
new file mode 100644
index 0000000..9e9df72
@@ -0,0 +1,548 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+
+
+static inline uint32_t
+delete_item(struct gro_vxlan_udp4_tbl *tbl,
+            uint32_t item_idx,
+            uint32_t prev_item_idx)
+{
+    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;
+
+    /* NULL indicates an empty item. */
+    tbl->items[item_idx].inner_item.firstseg = NULL;
+    tbl->item_num--;
+    if (prev_item_idx != INVALID_ARRAY_INDEX)
+            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;
+
+    return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,
+            struct vxlan_udp4_flow_key *src,
+            uint32_t item_idx)
+{
+    struct vxlan_udp4_flow_key *dst;
+    uint32_t flow_idx;
+
+    flow_idx = find_an_empty_flow(tbl);
+    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+            return INVALID_ARRAY_INDEX;
+
+    dst = &(tbl->flows[flow_idx].key);
+
+    rte_ether_addr_copy(&(src->inner_key.eth_saddr),
+                    &(dst->inner_key.eth_saddr));
+    rte_ether_addr_copy(&(src->inner_key.eth_daddr),
+                    &(dst->inner_key.eth_daddr));
+    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;
+    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;
+    dst->inner_key.ip_id = src->inner_key.ip_id;
+
+    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;
+    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;
+    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));
+    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));
+    dst->outer_ip_src_addr = src->outer_ip_src_addr;
+    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;
+    dst->outer_src_port = src->outer_src_port;
+    dst->outer_dst_port = src->outer_dst_port;
+
+    tbl->flows[flow_idx].start_index = item_idx;
+    tbl->flow_num++;
+
+    return flow_idx;
+}
+
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 192

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+static inline int
+is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
+            struct vxlan_udp4_flow_key k2)
+{
+    /* src port is changing, so shouldn't use it for flow check */

As I know, fragments of a vxlan/udp/ipv4 packet have same outer source port. In what cases outer source port will change?

In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port, protocol type).

ovs/lib/netdev-native-tnl.h:

static inline uint32_t *
dp_packet_rss_ptr(const struct dp_packet *b)

{
    return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);
}

static inline uint32_t
dp_packet_get_rss_hash(const struct dp_packet *p)

{
    return *dp_packet_rss_ptr(p);
}

static inline ovs_be16
netdev_tnl_get_src_port(struct dp_packet *packet)

{
    uint32_t hash;

    hash = dp_packet_get_rss_hash(packet);

    return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +
                 tnl_udp_port_min);
}

void
netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,
struct dp_packet *packet, const struct ovs_action_push_tnl *data)

{
    struct udp_header *udp;
    int ip_tot_size;

    udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    /* set udp src port */
    udp->udp_src = netdev_tnl_get_src_port(packet);
    udp->udp_len = htons(ip_tot_size);

    if (udp->udp_csum) {
        netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);
    }
}
Quoted 5 lines

This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The first fragment of original inner UDP is considered as different flow from other fragments.

I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

You are right. I checked VxLAN RFC 7348, and outer source port is calculated from inner packet. In OVS case, the first fragment will have different outer source port compared with other fragments. Please add some comments in the code for people to better understand the code. In addition, need to remove outer_src_port from the structure vxlan_udp4_flow_key.

Quoted 37 lines
Quoted 11 lines
Quoted 11 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
+                                    &k2.outer_eth_saddr) &&
+                    rte_is_same_ether_addr(&k1.outer_eth_daddr,
+                            &k2.outer_eth_daddr) &&
+                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&
+                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&
+                    (k1.outer_dst_port == k2.outer_dst_port) &&
+                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&
+                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&
+                    is_same_udp4_flow(k1.inner_key, k2.inner_key));
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c line 208

Quoted 6 lines
lib/librte_gro/gro_vxlan_udp4.c new file +6 -0
+}
+
+static inline int
+udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,
+            uint16_t frag_offset,
+            uint16_t ip_dl)

Better rename it as udp4_check_vxlan_neighbor.

Ok

Quoted 14 lines

lib/librte_gro/gro_vxlan_udp4.c line 217

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +9 -0
+{
+    struct rte_mbuf *pkt = item->inner_item.firstseg;
+    int cmp;
+    uint16_t l2_offset;
+    int ret = 0;
+
+    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
+    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,
+                                    l2_offset);

Why don't check outer IP ID? If outer DF bit is not set, all fragments should have incremental outer IP ID; if DF bit is set, we don't need to check outer IP ID.

Quoted 2 lines

By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check is enough to differentiate if they are same flow, isn't it?

OVS is one of workloads using DPDK, and we can assume other cases have the same design as OVS. I think IP ID check is necessary.

Quoted 197 lines
Quoted 3 lines

In addition, udp_check_neighbor is renamed, but you didn't change here.

Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will use meson build to check it for next version.

Quoted 181 lines
Quoted 181 lines
lib/librte_gro/gro_vxlan_udp4.c new file +81 -23
+    /* VXLAN outer IP ID is out of order, so don't touch it and
+     * don't compare it.
+     */
+    if (cmp > 0)
+            /* Append the new packet. */
+            ret = 1;
+    else if (cmp < 0)
+            /* Prepend the new packet. */
+            ret = -1;
+
+    return ret;
+}
+
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
+                    = {{{0}, 0, 0} };
+
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
                     = {{{0}, 0, 0} };
 
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
 
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];
 
     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;
-    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;
+    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,
                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
Quoted 8 lines

lib/librte_gro/gro_vxlan_udp4.c struct gro_ctx { · line 404

Quoted 5 lines
lib/librte_gro/gro_vxlan_udp4.c new file +5 -0
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;

Don't need to calculate left_nb_out here. In the previous patch, you also calculate it for UDP GRO. Please remove it both.

Quoted 1 line

I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

I don't think so. It's unnecessary for current design. If others want to add new GRO types, they will write correct code.

Quoted 7 lines
Quoted 2 lines
#10 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Quoted 9 lines · yang_y_yi

Jiayu, VM to VM case for big UDP packet (say udp parload size is 8192K, but mtu 1500). VM will segment it as UDP framgments, but when ovs dpdk uses VxLan to encapsulate them, it doesn't know they are same flow, OVS DPDK has no knowldge about them, just encapsulate them as if they are not related. But on receive side on another machine, OVS DPDK will GRO them, at this point, outer IP ID is even random for every packet. For TCP, I think same issue is there, GRO just considered them as different flow and doesn't do GRO, in my opinion, we also should do GRO for such case.

I am a little confused about ovs behavior. Does ovs know they are udp fragments? Or it knows they are fragments but doesn't know they are from one flow? Given ovs receives 3 udp fragments of a udp packet, if ovs doesn't know they are fragments of a udp packet, their mbuf->packet_type will be ether/ipv4/udp, ether/ipv4, and ether/ipv4. dpdk udp gro will not process the second and third one as their packet type in mbuf is not ether/ipv4/udp.

Quoted 1,240 lines

   2020-09-14 16:50:08  "Hu, Jiayu" <[email protected]> д    
    Out IP ID is not used to check if they belong to the same flow,

    but check if they are neighbors. If two vxlan/udp fragments are

    neighbors, their outer IP ID and outer frag_oft should be incremental.

    I still cannot understand why ignore outer IP ID when DF is 0.

    Can you give more explanation?

     

    From: yang_y_yi <[email protected]>
    Sent: Monday, September 14, 2020 4:27 PM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
    Importance: High

     

    For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so
    we can't use ip_id +/-1 to check if they are same flow, here is my
    incrmental change for it with more comments.

     

    @@ -189,7 +188,12 @@
     is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
                    struct vxlan_udp4_flow_key k2)
     {
    -       /* src port is changing, so shouldn't use it for flow check */
    +       /* For VxLAN packet, outer udp src port is calculated from
    +        * inner packet RSS hash, udp src port of the first UDP
    +        * fragment is different from one of other UDP fragments
    +        * even if they are same flow, so we have to skip outer udp
    +        * src port comparison here.
    +        */
            return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                            &k2.outer_eth_saddr) &&
                            rte_is_same_ether_addr(&k1.outer_eth_daddr,
    @@ -212,12 +216,16 @@
            uint16_t l2_offset;
            int ret = 0;

    +       /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,
    +        * we needn't compare outer_ip_id because they are same,
    +        * for the case outer_is_atomic is 1, we also have no way
    +        * to comapre outer_ip_id because the received packets can
    +        * be out of order. So ignore outer_ip_id comparison here.
    +        */
    +
            l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
            cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                            l2_offset);
    -       /* VXLAN outer IP ID is out of order, so don't touch it and
    -        * don't compare it.
    -        */
            if (cmp > 0)
                    /* Append the new packet. */
                    ret = 1;
    @@ -354,7 +362,9 @@
            rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &
    (key.outer_eth_daddr));
            key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
            key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;
    -       key.outer_src_port = udp_hdr->src_port;
    +       /* Note: It is unnecessary to save outer_src_port here because it
    can
    +        * be different for VxLAN UDP fragments from the same flow.
    +        */
            key.outer_dst_port = udp_hdr->dst_port;

            /* Search for a matched flow. */

     

     

     

    
    At 2020-09-14 12:21:26, "Jiayu Hu" <[email protected]> wrote:

    >Replies are inline.

    > 

    >BTW, you need to update the programmer guide

    >doc/guides/prog_guide/generic_receive_offload_lib.rst and

    >release note doc/guides/rel_notes/release_20_11.rst.

    > 

    >Thanks,

    >Jiayu

    > 

    >On Mon, Sep 14, 2020 at 10:13:44AM +0800, yang_y_yi wrote:

    >> Jiayu, thank you so much, please check my replies for some of your comments,

    >> here is incremental patch. I built it by meson this time :-)

    >> 

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >>                 frag_offset = tbl->items[item_idx].inner_item.frag_offset;

    >>                 is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >>                                         frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -481,12 +481,10 @@

    >>                                                         INVALID_ARRAY_INDEX);

    >>                                 tbl->items[start_idx].inner_item.next_pkt_idx

    >>                                         = item_idx;

    >> -                       } else {

    >> +                       } else

    >>                                 return 0;

    >> -                       }

    >> -               } else {

    >> +               } else

    >>                         return 0;

    >> -               }

    >>         }

    >> 

    >>         return 0;

    >> 

    >> 

    >> At 2020-09-11 12:24:16, "Jiayu Hu" <[email protected]> wrote:

    >> >Some comments are inline.

    >> >

    >> >Thanks,

    >> >Jiayu

    >> >

    >> >On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

    >> >> From: Yi Yang <[email protected]>

    >> >>

    >> >> VXLAN UDP GRO can help improve VM-to-VM UDP performance

    >> >> when VM is enabled UFO or GSO, GRO must be supported if

    >> >> GSO or UFO is enabled, otherwise, performance gain will

    >> >> be hurt.

    >> >>

    >> >> With this enabled in DPDK, OVS DPDK can leverage it to

    >> >> improve VM-to-VM UDP performance, this will make sure

    >> >> IP fragments will be reassembled once it is received

    >> >> from physical NIC. It is very helpful in OVS DPDK VXLAN

    >> >> TSO case.

    >> >>

    >> >> Signed-off-by: Yi Yang <[email protected]>

    >> >> ---

    >> >>  lib/librte_gro/gro_udp4.h       |   1 +

    >> >>  lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++

    >> >>  lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++

    >> >>  lib/librte_gro/meson.build      |   2 +-

    >> >>  lib/librte_gro/rte_gro.c        | 115 +++++++--

    >> >>  lib/librte_gro/rte_gro.h        |   3 +

    >> >>  6 files changed, 794 insertions(+), 27 deletions(-)

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.c

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.h

    >> >>

    >> >> diff --git a/lib/librte_gro/gro_udp4.h b/lib/librte_gro/gro_udp4.h

    >> >> index 0a078e4..d38b393 100644

    >> >> --- a/lib/librte_gro/gro_udp4.h

    >> >> +++ b/lib/librte_gro/gro_udp4.h

    >> >> @@ -7,6 +7,7 @@

    >> >>

    >> >>  #include <rte_ip.h>

    >> >>  #include <rte_udp.h>

    >> >> +#include <rte_vxlan.h>

    >> >>

    >> >>  #define INVALID_ARRAY_INDEX 0xffffffffUL

    >> >>  #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)

    >> >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> new file mode 100644

    >> >> index 0000000..9e9df72

    >> >> --- /dev/null

    >> >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> @@ -0,0 +1,548 @@

    >> >> +/* SPDX-License-Identifier: BSD-3-Clause

    >> >> + * Copyright(c) 2020 Inspur Corporation

    >> >> + */

    >> >> +

    >> >> +

    >> >> +

    >> >> +static inline uint32_t

    >> >> +delete_item(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            uint32_t item_idx,

    >> >> +            uint32_t prev_item_idx)

    >> >> +{

    >> >> +    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;

    >> >> +

    >> >> +    /* NULL indicates an empty item. */

    >> >> +    tbl->items[item_idx].inner_item.firstseg = NULL;

    >> >> +    tbl->item_num--;

    >> >> +    if (prev_item_idx != INVALID_ARRAY_INDEX)

    >> >> +            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;

    >> >> +

    >> >> +    return next_idx;

    >> >> +}

    >> >> +

    >> >> +static inline uint32_t

    >> >> +insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            struct vxlan_udp4_flow_key *src,

    >> >> +            uint32_t item_idx)

    >> >> +{

    >> >> +    struct vxlan_udp4_flow_key *dst;

    >> >> +    uint32_t flow_idx;

    >> >> +

    >> >> +    flow_idx = find_an_empty_flow(tbl);

    >> >> +    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))

    >> >> +            return INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +    dst = &(tbl->flows[flow_idx].key);

    >> >> +

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_saddr),

    >> >> +                    &(dst->inner_key.eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_daddr),

    >> >> +                    &(dst->inner_key.eth_daddr));

    >> >> +    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;

    >> >> +    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;

    >> >> +    dst->inner_key.ip_id = src->inner_key.ip_id;

    >> >> +

    >> >> +    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;

    >> >> +    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));

    >> >> +    dst->outer_ip_src_addr = src->outer_ip_src_addr;

    >> >> +    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;

    >> >> +    dst->outer_src_port = src->outer_src_port;

    >> >> +    dst->outer_dst_port = src->outer_dst_port;

    >> >> +

    >> >> +    tbl->flows[flow_idx].start_index = item_idx;

    >> >> +    tbl->flow_num++;

    >> >> +

    >> >> +    return flow_idx;

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,

    >> >> +            struct vxlan_udp4_flow_key k2)

    >> >> +{

    >> >> +    /* src port is changing, so shouldn't use it for flow check */

    >> >

    >> >As I know, fragments of a vxlan/udp/ipv4 packet have same outer source

    >> >port. In what cases outer source port will change?

    >> 

    >> In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is

    >> different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port,

    >> protocol type).

    >> 

    >> ovs/lib/netdev-native-tnl.h:

    >> 

    >> static inline uint32_t *

    >> dp_packet_rss_ptr(const struct dp_packet *b)

    >> {

    >>     return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);

    >> }

    >> 

    >> static inline uint32_t

    >> dp_packet_get_rss_hash(const struct dp_packet *p)

    >> {

    >>     return *dp_packet_rss_ptr(p);

    >> }

    >> 

    >> static inline ovs_be16

    >> netdev_tnl_get_src_port(struct dp_packet *packet)

    >> {

    >>     uint32_t hash;

    >> 

    >>     hash = dp_packet_get_rss_hash(packet);

    >> 

    >>     return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +

    >>                  tnl_udp_port_min);

    >> }

    >> 

    >> void

    >> netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,

    >>                            struct dp_packet *packet,

    >>                            const struct ovs_action_push_tnl *data)

    >> {

    >>     struct udp_header *udp;

    >>     int ip_tot_size;

    >> 

    >>     udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    >> 

    >>     /* set udp src port */

    >>     udp->udp_src = netdev_tnl_get_src_port(packet);

    >>     udp->udp_len = htons(ip_tot_size);

    >> 

    >>     if (udp->udp_csum) {

    >>         netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);

    >>     }

    >> }

    >> 

    >> This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The

    >> first fragment of original inner UDP is considered as different flow from other fragments.

    >> 

    >> I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

    >> 

    > 

    >You are right. I checked VxLAN RFC 7348, and outer source port is

    >calculated from inner packet. In OVS case, the first fragment

    >will have different outer source port compared with other fragments.

    >Please add some comments in the code for people to better understand

    >the code. In addition, need to remove outer_src_port from the structure

    >vxlan_udp4_flow_key.

    > 

    >> >

    >> >> +    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,

    >> >> +                                    &k2.outer_eth_saddr) &&

    >> >> +                    rte_is_same_ether_addr(&k1.outer_eth_daddr,

    >> >> +                            &k2.outer_eth_daddr) &&

    >> >> +                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&

    >> >> +                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&

    >> >> +                    (k1.outer_dst_port == k2.outer_dst_port) &&

    >> >> +                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&

    >> >> +                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&

    >> >> +                    is_same_udp4_flow(k1.inner_key, k2.inner_key));

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> >> +            uint16_t frag_offset,

    >> >> +            uint16_t ip_dl)

    >> >

    >> >Better rename it as udp4_check_vxlan_neighbor.

    >> 

    >> Ok

    >> 

    >> >

    >> >> +{

    >> >> +    struct rte_mbuf *pkt = item->inner_item.firstseg;

    >> >> +    int cmp;

    >> >> +    uint16_t l2_offset;

    >> >> +    int ret = 0;

    >> >> +

    >> >> +    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> >> +    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> >> +                                    l2_offset);

    >> >

    >> >Why don't check outer IP ID? If outer DF bit is not set, all fragments

    >> >should have incremental outer IP ID; if DF bit is set, we don't need

    >> >to check outer IP ID.

    >> 

    >> By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check

    >> is enough to differentiate if they are same flow, isn't it?

    > 

    >OVS is one of workloads using DPDK, and we can assume

    >other cases have the same design as OVS. I think IP ID

    >check is necessary.

    > 

    >> 

    >> >

    >> >In addition, udp_check_neighbor is renamed, but you didn't change here.

    >> 

    >> Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will

    >> use meson build to check it for next version.

    >> 

    >> >

    >> >> +    /* VXLAN outer IP ID is out of order, so don't touch it and

    >> >> +     * don't compare it.

    >> >> +     */

    >> >> +    if (cmp > 0)

    >> >> +            /* Append the new packet. */

    >> >> +            ret = 1;

    >> >> +    else if (cmp < 0)

    >> >> +            /* Prepend the new packet. */

    >> >> +            ret = -1;

    >> >> +

    >> >> +    return ret;

    >> >> +}

    >> >> +

    >> >>

    >> >>  /*

    >> >>   * GRO context structure. It keeps the table structures, which are

    >> >> @@ -137,19 +148,27 @@ struct gro_ctx {

    >> >>      struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };

    >> >>

    >> >>      /* Allocate a reassembly table for VXLAN TCP GRO */

    >> >> -    struct gro_vxlan_tcp4_tbl vxlan_tbl;

    >> >> -    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> -    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;

    >> >> +    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +                    = {{{0}, 0, 0} };

    >> >> +

    >> >> +    /* Allocate a reassembly table for VXLAN UDP GRO */

    >> >> +    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;

    >> >> +    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >>                      = {{{0}, 0, 0} };

    >> >>

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      uint32_t item_num;

    >> >>      int32_t ret;

    >> >>      uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;

    >> >> -    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;

    >> >> +    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,

    >> >> +            do_vxlan_udp_gro = 0;

    >> >>

    >> >>      if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >> @@ -160,15 +179,28 @@ struct gro_ctx {

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {

    >> >>              for (i = 0; i < item_num; i++)

    >> >> -                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> -

    >> >> -            vxlan_tbl.flows = vxlan_flows;

    >> >> -            vxlan_tbl.items = vxlan_items;

    >> >> -            vxlan_tbl.flow_num = 0;

    >> >> -            vxlan_tbl.item_num = 0;

    >> >> -            vxlan_tbl.max_flow_num = item_num;

    >> >> -            vxlan_tbl.max_item_num = item_num;

    >> >> -            do_vxlan_gro = 1;

    >> >> +                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_tcp_tbl.flows = vxlan_tcp_flows;

    >> >> +            vxlan_tcp_tbl.items = vxlan_tcp_items;

    >> >> +            vxlan_tcp_tbl.flow_num = 0;

    >> >> +            vxlan_tcp_tbl.item_num = 0;

    >> >> +            vxlan_tcp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_tcp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_tcp_gro = 1;

    >> >> +    }

    >> >> +

    >> >> +    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {

    >> >> +            for (i = 0; i < item_num; i++)

    >> >> +                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_udp_tbl.flows = vxlan_udp_flows;

    >> >> +            vxlan_udp_tbl.items = vxlan_udp_items;

    >> >> +            vxlan_udp_tbl.flow_num = 0;

    >> >> +            vxlan_udp_tbl.item_num = 0;

    >> >> +            vxlan_udp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_udp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_udp_gro = 1;

    >> >>      }

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_TCP_IPV4) {

    >> >> @@ -204,9 +236,18 @@ struct gro_ctx {

    >> >>               * will be flushed from the tables.

    >> >>               */

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> +                            do_vxlan_tcp_gro) {

    >> >>                      ret = gro_vxlan_tcp4_reassemble(pkts[i],

    >> >> -                                                    &vxlan_tbl, 0);

    >> >> +                                                    &vxlan_tcp_tbl, 0);

    >> >> +                    if (ret > 0)

    >> >> +                            /* Merge successfully */

    >> >> +                            nb_after_gro--;

    >> >> +                    else if (ret < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    ret = gro_vxlan_udp4_reassemble(pkts[i],

    >> >> +                                                    &vxlan_udp_tbl, 0);

    >> >>                      if (ret > 0)

    >> >>                              /* Merge successfully */

    >> >>                              nb_after_gro--;

    >> >> @@ -236,11 +277,17 @@ struct gro_ctx {

    >> >>               || (unprocess_num < nb_pkts)) {

    >> >>              i = 0;

    >> >>              /* Flush all packets from the tables */

    >> >> -            if (do_vxlan_gro) {

    >> >> -                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,

    >> >> +            if (do_vxlan_tcp_gro) {

    >> >> +                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,

    >> >>                                      0, pkts, nb_pkts);

    >> >>              }

    >> >>

    >> >> +            if (do_vxlan_udp_gro) {

    >> >> +                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,

    >> >> +                                    0, &pkts[i], nb_pkts - i);

    >> >> +

    >> >> +            }

    >> >> +

    >> >>              if (do_tcp4_gro) {

    >> >>                      i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,

    >> >>                                      &pkts[i], nb_pkts - i);

    >> >> @@ -269,33 +316,42 @@ struct gro_ctx {

    >> >>  {

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      struct gro_ctx *gro_ctx = ctx;

    >> >> -    void *tcp_tbl, *udp_tbl, *vxlan_tbl;

    >> >> +    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;

    >> >>      uint64_t current_time;

    >> >>      uint16_t i, unprocess_num = 0;

    >> >> -    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;

    >> >> +    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;

    >> >>

    >> >>      if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >>      tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];

    >> >> -    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >> +    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >>      udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];

    >> >> +    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

    >> >>

    >> >>      do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==

    >> >>              RTE_GRO_TCP_IPV4;

    >> >> -    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >> +    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >>              RTE_GRO_IPV4_VXLAN_TCP_IPV4;

    >> >>      do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==

    >> >>              RTE_GRO_UDP_IPV4;

    >> >> +    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

    >> >> +            RTE_GRO_IPV4_VXLAN_UDP_IPV4;

    >> >>

    >> >>      current_time = rte_rdtsc();

    >> >>

    >> >>      for (i = 0; i < nb_pkts; i++) {

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> -                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,

    >> >> +                            do_vxlan_tcp_gro) {

    >> >> +                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,

    >> >> +                                            current_time) < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,

    >> >>                                              current_time) < 0)

    >> >>                              unprocess_pkts[unprocess_num++] = pkts[i];

    >> >>              } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

    >> >> @@ -341,6 +397,13 @@ struct gro_ctx {

    >> >>              left_nb_out = max_nb_out - num;

    >> >>      }

    >> >>

    >> >> +    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {

    >> >> +            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[

    >> >> +                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],

    >> >> +                            flush_timestamp, &out[num], left_nb_out);

    >> >> +            left_nb_out = max_nb_out - num;

    >> >

    >> >Don't need to calculate left_nb_out here. In the previous patch, you

    >> >also calculate it for UDP GRO. Please remove it both.

    >> 

    >> I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

    > 

    >I don't think so. It's unnecessary for current design.

    >If others want to add new GRO types, they will write

    >correct code.

    > 

    >> 

    >> >

    >> 

    >> 

    >> 

    >>  

    >> 
author
#11 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

No, next_proto_id of inner IP header can clearly identify it is a UDP packet even if it is a no-udp-header ip fragment.

Quoted 1,258 lines · Jiayu Hu
Quoted 9 lines · yang_y_yi

Jiayu, VM to VM case for big UDP packet (say udp parload size is 8192K, but mtu 1500). VM will segment it as UDP framgments, but when ovs dpdk uses VxLan to encapsulate them, it doesn't know they are same flow, OVS DPDK has no knowldge about them, just encapsulate them as if they are not related. But on receive side on another machine, OVS DPDK will GRO them, at this point, outer IP ID is even random for every packet. For TCP, I think same issue is there, GRO just considered them as different flow and doesn't do GRO, in my opinion, we also should do GRO for such case.

I am a little confused about ovs behavior. Does ovs know they are udp fragments? Or it knows they are fragments but doesn't know they are from one flow? Given ovs receives 3 udp fragments of a udp packet, if ovs doesn't know they are fragments of a udp packet, their mbuf->packet_type will be ether/ipv4/udp, ether/ipv4, and ether/ipv4. dpdk udp gro will not process the second and third one as their packet type in mbuf is not ether/ipv4/udp.

Quoted 1,240 lines

   2020-09-14 16:50:08  "Hu, Jiayu" <[email protected]> д    
    Out IP ID is not used to check if they belong to the same flow,

    but check if they are neighbors. If two vxlan/udp fragments are

    neighbors, their outer IP ID and outer frag_oft should be incremental.

    I still cannot understand why ignore outer IP ID when DF is 0.

    Can you give more explanation?

     

    From: yang_y_yi <[email protected]>
    Sent: Monday, September 14, 2020 4:27 PM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
    Importance: High

     

    For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so
    we can't use ip_id +/-1 to check if they are same flow, here is my
    incrmental change for it with more comments.

     

    @@ -189,7 +188,12 @@
     is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
                    struct vxlan_udp4_flow_key k2)
     {
    -       /* src port is changing, so shouldn't use it for flow check */
    +       /* For VxLAN packet, outer udp src port is calculated from
    +        * inner packet RSS hash, udp src port of the first UDP
    +        * fragment is different from one of other UDP fragments
    +        * even if they are same flow, so we have to skip outer udp
    +        * src port comparison here.
    +        */
            return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                            &k2.outer_eth_saddr) &&
                            rte_is_same_ether_addr(&k1.outer_eth_daddr,
    @@ -212,12 +216,16 @@
            uint16_t l2_offset;
            int ret = 0;

    +       /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,
    +        * we needn't compare outer_ip_id because they are same,
    +        * for the case outer_is_atomic is 1, we also have no way
    +        * to comapre outer_ip_id because the received packets can
    +        * be out of order. So ignore outer_ip_id comparison here.
    +        */
    +
            l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
            cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                            l2_offset);
    -       /* VXLAN outer IP ID is out of order, so don't touch it and
    -        * don't compare it.
    -        */
            if (cmp > 0)
                    /* Append the new packet. */
                    ret = 1;
    @@ -354,7 +362,9 @@
            rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &
    (key.outer_eth_daddr));
            key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
            key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;
    -       key.outer_src_port = udp_hdr->src_port;
    +       /* Note: It is unnecessary to save outer_src_port here because it
    can
    +        * be different for VxLAN UDP fragments from the same flow.
    +        */
            key.outer_dst_port = udp_hdr->dst_port;

            /* Search for a matched flow. */

     

     

     

    
    At 2020-09-14 12:21:26, "Jiayu Hu" <[email protected]> wrote:

    >Replies are inline.

    > 

    >BTW, you need to update the programmer guide

    >doc/guides/prog_guide/generic_receive_offload_lib.rst and

    >release note doc/guides/rel_notes/release_20_11.rst.

    > 

    >Thanks,

    >Jiayu

    > 

    >On Mon, Sep 14, 2020 at 10:13:44AM +0800, yang_y_yi wrote:

    >> Jiayu, thank you so much, please check my replies for some of your comments,

    >> here is incremental patch. I built it by meson this time :-)

    >> 

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >>                 frag_offset = tbl->items[item_idx].inner_item.frag_offset;

    >>                 is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >>                                         frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -481,12 +481,10 @@

    >>                                                         INVALID_ARRAY_INDEX);

    >>                                 tbl->items[start_idx].inner_item.next_pkt_idx

    >>                                         = item_idx;

    >> -                       } else {

    >> +                       } else

    >>                                 return 0;

    >> -                       }

    >> -               } else {

    >> +               } else

    >>                         return 0;

    >> -               }

    >>         }

    >> 

    >>         return 0;

    >> 

    >> 

    >> At 2020-09-11 12:24:16, "Jiayu Hu" <[email protected]> wrote:

    >> >Some comments are inline.

    >> >

    >> >Thanks,

    >> >Jiayu

    >> >

    >> >On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

    >> >> From: Yi Yang <[email protected]>

    >> >>

    >> >> VXLAN UDP GRO can help improve VM-to-VM UDP performance

    >> >> when VM is enabled UFO or GSO, GRO must be supported if

    >> >> GSO or UFO is enabled, otherwise, performance gain will

    >> >> be hurt.

    >> >>

    >> >> With this enabled in DPDK, OVS DPDK can leverage it to

    >> >> improve VM-to-VM UDP performance, this will make sure

    >> >> IP fragments will be reassembled once it is received

    >> >> from physical NIC. It is very helpful in OVS DPDK VXLAN

    >> >> TSO case.

    >> >>

    >> >> Signed-off-by: Yi Yang <[email protected]>

    >> >> ---

    >> >>  lib/librte_gro/gro_udp4.h       |   1 +

    >> >>  lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++

    >> >>  lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++

    >> >>  lib/librte_gro/meson.build      |   2 +-

    >> >>  lib/librte_gro/rte_gro.c        | 115 +++++++--

    >> >>  lib/librte_gro/rte_gro.h        |   3 +

    >> >>  6 files changed, 794 insertions(+), 27 deletions(-)

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.c

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.h

    >> >>

    >> >> diff --git a/lib/librte_gro/gro_udp4.h b/lib/librte_gro/gro_udp4.h

    >> >> index 0a078e4..d38b393 100644

    >> >> --- a/lib/librte_gro/gro_udp4.h

    >> >> +++ b/lib/librte_gro/gro_udp4.h

    >> >> @@ -7,6 +7,7 @@

    >> >>

    >> >>  #include <rte_ip.h>

    >> >>  #include <rte_udp.h>

    >> >> +#include <rte_vxlan.h>

    >> >>

    >> >>  #define INVALID_ARRAY_INDEX 0xffffffffUL

    >> >>  #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)

    >> >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> new file mode 100644

    >> >> index 0000000..9e9df72

    >> >> --- /dev/null

    >> >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> @@ -0,0 +1,548 @@

    >> >> +/* SPDX-License-Identifier: BSD-3-Clause

    >> >> + * Copyright(c) 2020 Inspur Corporation

    >> >> + */

    >> >> +

    >> >> +

    >> >> +

    >> >> +static inline uint32_t

    >> >> +delete_item(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            uint32_t item_idx,

    >> >> +            uint32_t prev_item_idx)

    >> >> +{

    >> >> +    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;

    >> >> +

    >> >> +    /* NULL indicates an empty item. */

    >> >> +    tbl->items[item_idx].inner_item.firstseg = NULL;

    >> >> +    tbl->item_num--;

    >> >> +    if (prev_item_idx != INVALID_ARRAY_INDEX)

    >> >> +            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;

    >> >> +

    >> >> +    return next_idx;

    >> >> +}

    >> >> +

    >> >> +static inline uint32_t

    >> >> +insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            struct vxlan_udp4_flow_key *src,

    >> >> +            uint32_t item_idx)

    >> >> +{

    >> >> +    struct vxlan_udp4_flow_key *dst;

    >> >> +    uint32_t flow_idx;

    >> >> +

    >> >> +    flow_idx = find_an_empty_flow(tbl);

    >> >> +    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))

    >> >> +            return INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +    dst = &(tbl->flows[flow_idx].key);

    >> >> +

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_saddr),

    >> >> +                    &(dst->inner_key.eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_daddr),

    >> >> +                    &(dst->inner_key.eth_daddr));

    >> >> +    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;

    >> >> +    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;

    >> >> +    dst->inner_key.ip_id = src->inner_key.ip_id;

    >> >> +

    >> >> +    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;

    >> >> +    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));

    >> >> +    dst->outer_ip_src_addr = src->outer_ip_src_addr;

    >> >> +    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;

    >> >> +    dst->outer_src_port = src->outer_src_port;

    >> >> +    dst->outer_dst_port = src->outer_dst_port;

    >> >> +

    >> >> +    tbl->flows[flow_idx].start_index = item_idx;

    >> >> +    tbl->flow_num++;

    >> >> +

    >> >> +    return flow_idx;

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,

    >> >> +            struct vxlan_udp4_flow_key k2)

    >> >> +{

    >> >> +    /* src port is changing, so shouldn't use it for flow check */

    >> >

    >> >As I know, fragments of a vxlan/udp/ipv4 packet have same outer source

    >> >port. In what cases outer source port will change?

    >> 

    >> In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is

    >> different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port,

    >> protocol type).

    >> 

    >> ovs/lib/netdev-native-tnl.h:

    >> 

    >> static inline uint32_t *

    >> dp_packet_rss_ptr(const struct dp_packet *b)

    >> {

    >>     return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);

    >> }

    >> 

    >> static inline uint32_t

    >> dp_packet_get_rss_hash(const struct dp_packet *p)

    >> {

    >>     return *dp_packet_rss_ptr(p);

    >> }

    >> 

    >> static inline ovs_be16

    >> netdev_tnl_get_src_port(struct dp_packet *packet)

    >> {

    >>     uint32_t hash;

    >> 

    >>     hash = dp_packet_get_rss_hash(packet);

    >> 

    >>     return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +

    >>                  tnl_udp_port_min);

    >> }

    >> 

    >> void

    >> netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,

    >>                            struct dp_packet *packet,

    >>                            const struct ovs_action_push_tnl *data)

    >> {

    >>     struct udp_header *udp;

    >>     int ip_tot_size;

    >> 

    >>     udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    >> 

    >>     /* set udp src port */

    >>     udp->udp_src = netdev_tnl_get_src_port(packet);

    >>     udp->udp_len = htons(ip_tot_size);

    >> 

    >>     if (udp->udp_csum) {

    >>         netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);

    >>     }

    >> }

    >> 

    >> This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The

    >> first fragment of original inner UDP is considered as different flow from other fragments.

    >> 

    >> I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

    >> 

    > 

    >You are right. I checked VxLAN RFC 7348, and outer source port is

    >calculated from inner packet. In OVS case, the first fragment

    >will have different outer source port compared with other fragments.

    >Please add some comments in the code for people to better understand

    >the code. In addition, need to remove outer_src_port from the structure

    >vxlan_udp4_flow_key.

    > 

    >> >

    >> >> +    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,

    >> >> +                                    &k2.outer_eth_saddr) &&

    >> >> +                    rte_is_same_ether_addr(&k1.outer_eth_daddr,

    >> >> +                            &k2.outer_eth_daddr) &&

    >> >> +                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&

    >> >> +                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&

    >> >> +                    (k1.outer_dst_port == k2.outer_dst_port) &&

    >> >> +                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&

    >> >> +                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&

    >> >> +                    is_same_udp4_flow(k1.inner_key, k2.inner_key));

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> >> +            uint16_t frag_offset,

    >> >> +            uint16_t ip_dl)

    >> >

    >> >Better rename it as udp4_check_vxlan_neighbor.

    >> 

    >> Ok

    >> 

    >> >

    >> >> +{

    >> >> +    struct rte_mbuf *pkt = item->inner_item.firstseg;

    >> >> +    int cmp;

    >> >> +    uint16_t l2_offset;

    >> >> +    int ret = 0;

    >> >> +

    >> >> +    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> >> +    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> >> +                                    l2_offset);

    >> >

    >> >Why don't check outer IP ID? If outer DF bit is not set, all fragments

    >> >should have incremental outer IP ID; if DF bit is set, we don't need

    >> >to check outer IP ID.

    >> 

    >> By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check

    >> is enough to differentiate if they are same flow, isn't it?

    > 

    >OVS is one of workloads using DPDK, and we can assume

    >other cases have the same design as OVS. I think IP ID

    >check is necessary.

    > 

    >> 

    >> >

    >> >In addition, udp_check_neighbor is renamed, but you didn't change here.

    >> 

    >> Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will

    >> use meson build to check it for next version.

    >> 

    >> >

    >> >> +    /* VXLAN outer IP ID is out of order, so don't touch it and

    >> >> +     * don't compare it.

    >> >> +     */

    >> >> +    if (cmp > 0)

    >> >> +            /* Append the new packet. */

    >> >> +            ret = 1;

    >> >> +    else if (cmp < 0)

    >> >> +            /* Prepend the new packet. */

    >> >> +            ret = -1;

    >> >> +

    >> >> +    return ret;

    >> >> +}

    >> >> +

    >> >>

    >> >>  /*

    >> >>   * GRO context structure. It keeps the table structures, which are

    >> >> @@ -137,19 +148,27 @@ struct gro_ctx {

    >> >>      struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };

    >> >>

    >> >>      /* Allocate a reassembly table for VXLAN TCP GRO */

    >> >> -    struct gro_vxlan_tcp4_tbl vxlan_tbl;

    >> >> -    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> -    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;

    >> >> +    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +                    = {{{0}, 0, 0} };

    >> >> +

    >> >> +    /* Allocate a reassembly table for VXLAN UDP GRO */

    >> >> +    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;

    >> >> +    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >>                      = {{{0}, 0, 0} };

    >> >>

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      uint32_t item_num;

    >> >>      int32_t ret;

    >> >>      uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;

    >> >> -    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;

    >> >> +    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,

    >> >> +            do_vxlan_udp_gro = 0;

    >> >>

    >> >>      if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >> @@ -160,15 +179,28 @@ struct gro_ctx {

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {

    >> >>              for (i = 0; i < item_num; i++)

    >> >> -                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> -

    >> >> -            vxlan_tbl.flows = vxlan_flows;

    >> >> -            vxlan_tbl.items = vxlan_items;

    >> >> -            vxlan_tbl.flow_num = 0;

    >> >> -            vxlan_tbl.item_num = 0;

    >> >> -            vxlan_tbl.max_flow_num = item_num;

    >> >> -            vxlan_tbl.max_item_num = item_num;

    >> >> -            do_vxlan_gro = 1;

    >> >> +                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_tcp_tbl.flows = vxlan_tcp_flows;

    >> >> +            vxlan_tcp_tbl.items = vxlan_tcp_items;

    >> >> +            vxlan_tcp_tbl.flow_num = 0;

    >> >> +            vxlan_tcp_tbl.item_num = 0;

    >> >> +            vxlan_tcp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_tcp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_tcp_gro = 1;

    >> >> +    }

    >> >> +

    >> >> +    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {

    >> >> +            for (i = 0; i < item_num; i++)

    >> >> +                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_udp_tbl.flows = vxlan_udp_flows;

    >> >> +            vxlan_udp_tbl.items = vxlan_udp_items;

    >> >> +            vxlan_udp_tbl.flow_num = 0;

    >> >> +            vxlan_udp_tbl.item_num = 0;

    >> >> +            vxlan_udp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_udp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_udp_gro = 1;

    >> >>      }

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_TCP_IPV4) {

    >> >> @@ -204,9 +236,18 @@ struct gro_ctx {

    >> >>               * will be flushed from the tables.

    >> >>               */

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> +                            do_vxlan_tcp_gro) {

    >> >>                      ret = gro_vxlan_tcp4_reassemble(pkts[i],

    >> >> -                                                    &vxlan_tbl, 0);

    >> >> +                                                    &vxlan_tcp_tbl, 0);

    >> >> +                    if (ret > 0)

    >> >> +                            /* Merge successfully */

    >> >> +                            nb_after_gro--;

    >> >> +                    else if (ret < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    ret = gro_vxlan_udp4_reassemble(pkts[i],

    >> >> +                                                    &vxlan_udp_tbl, 0);

    >> >>                      if (ret > 0)

    >> >>                              /* Merge successfully */

    >> >>                              nb_after_gro--;

    >> >> @@ -236,11 +277,17 @@ struct gro_ctx {

    >> >>               || (unprocess_num < nb_pkts)) {

    >> >>              i = 0;

    >> >>              /* Flush all packets from the tables */

    >> >> -            if (do_vxlan_gro) {

    >> >> -                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,

    >> >> +            if (do_vxlan_tcp_gro) {

    >> >> +                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,

    >> >>                                      0, pkts, nb_pkts);

    >> >>              }

    >> >>

    >> >> +            if (do_vxlan_udp_gro) {

    >> >> +                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,

    >> >> +                                    0, &pkts[i], nb_pkts - i);

    >> >> +

    >> >> +            }

    >> >> +

    >> >>              if (do_tcp4_gro) {

    >> >>                      i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,

    >> >>                                      &pkts[i], nb_pkts - i);

    >> >> @@ -269,33 +316,42 @@ struct gro_ctx {

    >> >>  {

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      struct gro_ctx *gro_ctx = ctx;

    >> >> -    void *tcp_tbl, *udp_tbl, *vxlan_tbl;

    >> >> +    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;

    >> >>      uint64_t current_time;

    >> >>      uint16_t i, unprocess_num = 0;

    >> >> -    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;

    >> >> +    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;

    >> >>

    >> >>      if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >>      tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];

    >> >> -    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >> +    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >>      udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];

    >> >> +    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

    >> >>

    >> >>      do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==

    >> >>              RTE_GRO_TCP_IPV4;

    >> >> -    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >> +    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >>              RTE_GRO_IPV4_VXLAN_TCP_IPV4;

    >> >>      do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==

    >> >>              RTE_GRO_UDP_IPV4;

    >> >> +    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

    >> >> +            RTE_GRO_IPV4_VXLAN_UDP_IPV4;

    >> >>

    >> >>      current_time = rte_rdtsc();

    >> >>

    >> >>      for (i = 0; i < nb_pkts; i++) {

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> -                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,

    >> >> +                            do_vxlan_tcp_gro) {

    >> >> +                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,

    >> >> +                                            current_time) < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,

    >> >>                                              current_time) < 0)

    >> >>                              unprocess_pkts[unprocess_num++] = pkts[i];

    >> >>              } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

    >> >> @@ -341,6 +397,13 @@ struct gro_ctx {

    >> >>              left_nb_out = max_nb_out - num;

    >> >>      }

    >> >>

    >> >> +    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {

    >> >> +            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[

    >> >> +                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],

    >> >> +                            flush_timestamp, &out[num], left_nb_out);

    >> >> +            left_nb_out = max_nb_out - num;

    >> >

    >> >Don't need to calculate left_nb_out here. In the previous patch, you

    >> >also calculate it for UDP GRO. Please remove it both.

    >> 

    >> I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

    > 

    >I don't think so. It's unnecessary for current design.

    >If others want to add new GRO types, they will write

    >correct code.

    > 

    >> 

    >> >

    >> 

    >> 

    >> 

    >>  

    >> 
#12 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Quoted 1 line · On Wed, 16 Sep 2020 11:05:38 +0800 (CST) yang_y_yi <[email protected]> wrote:

No, next_proto_id of inner IP header can clearly identify it is a UDP packet even if it is a no-udp-header ip fragment.

Yes GRO will know its UDP, but it will have no port information (in this packet). GRO can only safely combine packets from the same flow. Since there is no port in this packet, it is not sufficient to identify the inner flow.

#13 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

In reply to yang_y_yi

OK, I agree to ignore processing outer IP ID. But I think the comment need to change, as it is not accurate. VxLAN/UDP GRO doesn't process outer IP ID is because it is meaningless for reassembly in the ovs case you mentioned, rather than it's out-of-order. You can give the ovs example in the commit log, and it's easier to understand the code IMO.

Thanks,
Jiayu

From: yang_y_yi <[email protected]>
Sent: Wednesday, September 16, 2020 11:06 AM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: RE: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
Importance: High

No, next_proto_id of inner IP header can clearly identify it is a UDP packet even if it is a no-udp-header ip fragment.

Quoted 2,515 lines · At 2020-09-16 10:54:24, "Jiayu Hu" <[email protected]<mailto:[email protected]…
Quoted 10 lines · yang_y_yi

Jiayu, VM to VM case for big UDP packet (say udp parload size is 8192K, but mtu

1500). VM will segment it as UDP framgments, but when ovs dpdk uses VxLan to

encapsulate them, it doesn't know they are same flow, OVS DPDK has no knowldge

about them, just encapsulate them as if they are not related. But on receive

Quoted 7 lines

side on another machine, OVS DPDK will GRO them, at this point, outer IP ID is

even random for every packet. For TCP, I think same issue is there, GRO just

considered them as different flow and doesn't do GRO, in my opinion, we also

should do GRO for such case.

I am a little confused about ovs behavior. Does ovs know they are udp fragments?

Or it knows they are fragments but doesn't know they are from one flow?

Given ovs receives 3 udp fragments of a udp packet, if ovs doesn't know they are

fragments of a udp packet, their mbuf->packet_type will be ether/ipv4/udp,

ether/ipv4, and ether/ipv4. dpdk udp gro will not process the second and third

one as their packet type in mbuf is not ether/ipv4/udp.

Quoted 2,479 lines



   2020-09-14 16:50:08  "Hu, Jiayu" <[email protected]<mailto:[email protected]>> д
    Out IP ID is not used to check if they belong to the same flow,



    but check if they are neighbors. If two vxlan/udp fragments are



    neighbors, their outer IP ID and outer frag_oft should be incremental.



    I still cannot understand why ignore outer IP ID when DF is 0.



    Can you give more explanation?







    From: yang_y_yi <[email protected]<mailto:[email protected]>>

    Sent: Monday, September 14, 2020 4:27 PM

    To: Hu, Jiayu <[email protected]<mailto:[email protected]>>

    Cc: [email protected]<mailto:[email protected]>; [email protected]<mailto:[email protected]>; [email protected]<mailto:[email protected]>

    Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support

    Importance: High







    For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so

    we can't use ip_id +/-1 to check if they are same flow, here is my

    incrmental change for it with more comments.







    @@ -189,7 +188,12 @@

     is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,

                    struct vxlan_udp4_flow_key k2)

     {

    -       /* src port is changing, so shouldn't use it for flow check */

    +       /* For VxLAN packet, outer udp src port is calculated from

    +        * inner packet RSS hash, udp src port of the first UDP

    +        * fragment is different from one of other UDP fragments

    +        * even if they are same flow, so we have to skip outer udp

    +        * src port comparison here.

    +        */

            return (rte_is_same_ether_addr(&k1.outer_eth_saddr,

                                            &k2.outer_eth_saddr) &&

                            rte_is_same_ether_addr(&k1.outer_eth_daddr,

    @@ -212,12 +216,16 @@

            uint16_t l2_offset;

            int ret = 0;



    +       /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,

    +        * we needn't compare outer_ip_id because they are same,

    +        * for the case outer_is_atomic is 1, we also have no way

    +        * to comapre outer_ip_id because the received packets can

    +        * be out of order. So ignore outer_ip_id comparison here.

    +        */

    +

            l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

            cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

                                            l2_offset);

    -       /* VXLAN outer IP ID is out of order, so don't touch it and

    -        * don't compare it.

    -        */

            if (cmp > 0)

                    /* Append the new packet. */

                    ret = 1;

    @@ -354,7 +362,9 @@

            rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &

    (key.outer_eth_daddr));

            key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;

            key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;

    -       key.outer_src_port = udp_hdr->src_port;

    +       /* Note: It is unnecessary to save outer_src_port here because it

    can

    +        * be different for VxLAN UDP fragments from the same flow.

    +        */

            key.outer_dst_port = udp_hdr->dst_port;



            /* Search for a matched flow. */

















    At 2020-09-14 12:21:26, "Jiayu Hu" <[email protected]<mailto:[email protected]>> wrote:



    >Replies are inline.



    >



    >BTW, you need to update the programmer guide



    >doc/guides/prog_guide/generic_receive_offload_lib.rst and



    >release note doc/guides/rel_notes/release_20_11.rst.



    >



    >Thanks,



    >Jiayu



    >



    >On Mon, Sep 14, 2020 at 10:13:44AM +0800, yang_y_yi wrote:



    >> Jiayu, thank you so much, please check my replies for some of your comments,



    >> here is incremental patch. I built it by meson this time :-)



    >>



    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c



    >> index 9e9df72..1fcfaf1 100644



    >> --- a/lib/librte_gro/gro_vxlan_udp4.c



    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c



    >> @@ -203,7 +203,7 @@



    >>  }



    >>



    >>  static inline int



    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,



    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,



    >>                 uint16_t frag_offset,



    >>                 uint16_t ip_dl)



    >>  {



    >> @@ -213,7 +213,7 @@



    >>         int ret = 0;



    >>



    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;



    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,



    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,



    >>                                         l2_offset);



    >>         /* VXLAN outer IP ID is out of order, so don't touch it and



    >>          * don't compare it.



    >> @@ -379,7 +379,7 @@



    >>                 item_idx = insert_new_item(tbl, pkt, start_time,



    >>                                 INVALID_ARRAY_INDEX, frag_offset,



    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);



    >> -               if (item_idx == INVALID_ARRAY_INDEX)



    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))



    >>                         return -1;



    >>                 if (insert_new_flow(tbl, &key, item_idx) ==



    >>                                 INVALID_ARRAY_INDEX) {



    >> @@ -397,7 +397,7 @@



    >>         cur_idx = tbl->flows[i].start_index;



    >>         prev_idx = cur_idx;



    >>         do {



    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),



    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),



    >>                                 frag_offset, ip_dl);



    >>                 if (cmp) {



    >>                         if (merge_two_vxlan_udp4_packets(



    >> @@ -436,7 +436,7 @@



    >>                 item_idx = insert_new_item(tbl, pkt, start_time,



    >>                                 INVALID_ARRAY_INDEX, frag_offset,



    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);



    >> -               if (item_idx == INVALID_ARRAY_INDEX)



    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))



    >>                         return -1;



    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;



    >>                 tbl->flows[i].start_index = item_idx;



    >> @@ -470,7 +470,7 @@



    >>                 ip_dl = pkt->pkt_len - hdr_len;



    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c



    >> index 9e9df72..1fcfaf1 100644



    >> --- a/lib/librte_gro/gro_vxlan_udp4.c



    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c



    >> @@ -203,7 +203,7 @@



    >>  }



    >>



    >>  static inline int



    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,



    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,



    >>                 uint16_t frag_offset,



    >>                 uint16_t ip_dl)



    >>  {



    >> @@ -213,7 +213,7 @@



    >>         int ret = 0;



    >>



    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;



    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,



    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,



    >>                                         l2_offset);



    >>         /* VXLAN outer IP ID is out of order, so don't touch it and



    >>          * don't compare it.



    >> @@ -379,7 +379,7 @@



    >>                 item_idx = insert_new_item(tbl, pkt, start_time,



    >>                                 INVALID_ARRAY_INDEX, frag_offset,



    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);



    >> -               if (item_idx == INVALID_ARRAY_INDEX)



    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))



    >>                         return -1;



    >>                 if (insert_new_flow(tbl, &key, item_idx) ==



    >>                                 INVALID_ARRAY_INDEX) {



    >> @@ -397,7 +397,7 @@



    >>         cur_idx = tbl->flows[i].start_index;



    >>         prev_idx = cur_idx;



    >>         do {



    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),



    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),



    >>                                 frag_offset, ip_dl);



    >>                 if (cmp) {



    >>                         if (merge_two_vxlan_udp4_packets(



    >> @@ -436,7 +436,7 @@



    >>                 item_idx = insert_new_item(tbl, pkt, start_time,



    >>                                 INVALID_ARRAY_INDEX, frag_offset,



    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);



    >> -               if (item_idx == INVALID_ARRAY_INDEX)



    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))



    >>                         return -1;



    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;



    >>                 tbl->flows[i].start_index = item_idx;



    >> @@ -470,7 +470,7 @@



    >>                 ip_dl = pkt->pkt_len - hdr_len;



    >>                 frag_offset = tbl->items[item_idx].inner_item.frag_offset;



    >>                 is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;



    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),



    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),



    >>                                         frag_offset, ip_dl);



    >>                 if (cmp) {



    >>                         if (merge_two_vxlan_udp4_packets(



    >> @@ -481,12 +481,10 @@



    >>                                                         INVALID_ARRAY_INDEX);



    >>                                 tbl->items[start_idx].inner_item.next_pkt_idx



    >>                                         = item_idx;



    >> -                       } else {



    >> +                       } else



    >>                                 return 0;



    >> -                       }



    >> -               } else {



    >> +               } else



    >>                         return 0;



    >> -               }



    >>         }



    >>



    >>         return 0;



    >>



    >>



    >> At 2020-09-11 12:24:16, "Jiayu Hu" <[email protected]<mailto:[email protected]>> wrote:



    >> >Some comments are inline.



    >> >



    >> >Thanks,



    >> >Jiayu



    >> >



    >> >On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected]<mailto:[email protected]> wrote:



    >> >> From: Yi Yang <[email protected]<mailto:[email protected]>>



    >> >>



    >> >> VXLAN UDP GRO can help improve VM-to-VM UDP performance



    >> >> when VM is enabled UFO or GSO, GRO must be supported if



    >> >> GSO or UFO is enabled, otherwise, performance gain will



    >> >> be hurt.



    >> >>



    >> >> With this enabled in DPDK, OVS DPDK can leverage it to



    >> >> improve VM-to-VM UDP performance, this will make sure



    >> >> IP fragments will be reassembled once it is received



    >> >> from physical NIC. It is very helpful in OVS DPDK VXLAN



    >> >> TSO case.



    >> >>



    >> >> Signed-off-by: Yi Yang <[email protected]<mailto:[email protected]>>



    >> >> ---



    >> >>  lib/librte_gro/gro_udp4.h       |   1 +



    >> >>  lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++



    >> >>  lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++



    >> >>  lib/librte_gro/meson.build      |   2 +-



    >> >>  lib/librte_gro/rte_gro.c        | 115 +++++++--



    >> >>  lib/librte_gro/rte_gro.h        |   3 +



    >> >>  6 files changed, 794 insertions(+), 27 deletions(-)



    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.c



    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.h



    >> >>



    >> >> diff --git a/lib/librte_gro/gro_udp4.h b/lib/librte_gro/gro_udp4.h



    >> >> index 0a078e4..d38b393 100644



    >> >> --- a/lib/librte_gro/gro_udp4.h



    >> >> +++ b/lib/librte_gro/gro_udp4.h



    >> >> @@ -7,6 +7,7 @@



    >> >>



    >> >>  #include <rte_ip.h>



    >> >>  #include <rte_udp.h>



    >> >> +#include <rte_vxlan.h>



    >> >>



    >> >>  #define INVALID_ARRAY_INDEX 0xffffffffUL



    >> >>  #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)



    >> >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c



    >> >> new file mode 100644



    >> >> index 0000000..9e9df72



    >> >> --- /dev/null



    >> >> +++ b/lib/librte_gro/gro_vxlan_udp4.c



    >> >> @@ -0,0 +1,548 @@



    >> >> +/* SPDX-License-Identifier: BSD-3-Clause



    >> >> + * Copyright(c) 2020 Inspur Corporation



    >> >> + */



    >> >> +



    >> >> +



    >> >> +



    >> >> +static inline uint32_t



    >> >> +delete_item(struct gro_vxlan_udp4_tbl *tbl,



    >> >> +            uint32_t item_idx,



    >> >> +            uint32_t prev_item_idx)



    >> >> +{



    >> >> +    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;



    >> >> +



    >> >> +    /* NULL indicates an empty item. */



    >> >> +    tbl->items[item_idx].inner_item.firstseg = NULL;



    >> >> +    tbl->item_num--;



    >> >> +    if (prev_item_idx != INVALID_ARRAY_INDEX)



    >> >> +            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;



    >> >> +



    >> >> +    return next_idx;



    >> >> +}



    >> >> +



    >> >> +static inline uint32_t



    >> >> +insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,



    >> >> +            struct vxlan_udp4_flow_key *src,



    >> >> +            uint32_t item_idx)



    >> >> +{



    >> >> +    struct vxlan_udp4_flow_key *dst;



    >> >> +    uint32_t flow_idx;



    >> >> +



    >> >> +    flow_idx = find_an_empty_flow(tbl);



    >> >> +    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))



    >> >> +            return INVALID_ARRAY_INDEX;



    >> >> +



    >> >> +    dst = &(tbl->flows[flow_idx].key);



    >> >> +



    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_saddr),



    >> >> +                    &(dst->inner_key.eth_saddr));



    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_daddr),



    >> >> +                    &(dst->inner_key.eth_daddr));



    >> >> +    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;



    >> >> +    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;



    >> >> +    dst->inner_key.ip_id = src->inner_key.ip_id;



    >> >> +



    >> >> +    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;



    >> >> +    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;



    >> >> +    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));



    >> >> +    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));



    >> >> +    dst->outer_ip_src_addr = src->outer_ip_src_addr;



    >> >> +    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;



    >> >> +    dst->outer_src_port = src->outer_src_port;



    >> >> +    dst->outer_dst_port = src->outer_dst_port;



    >> >> +



    >> >> +    tbl->flows[flow_idx].start_index = item_idx;



    >> >> +    tbl->flow_num++;



    >> >> +



    >> >> +    return flow_idx;



    >> >> +}



    >> >> +



    >> >> +static inline int



    >> >> +is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,



    >> >> +            struct vxlan_udp4_flow_key k2)



    >> >> +{



    >> >> +    /* src port is changing, so shouldn't use it for flow check */



    >> >



    >> >As I know, fragments of a vxlan/udp/ipv4 packet have same outer source



    >> >port. In what cases outer source port will change?



    >>



    >> In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is



    >> different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port,



    >> protocol type).



    >>



    >> ovs/lib/netdev-native-tnl.h:



    >>



    >> static inline uint32_t *



    >> dp_packet_rss_ptr(const struct dp_packet *b)



    >> {



    >>     return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);



    >> }



    >>



    >> static inline uint32_t



    >> dp_packet_get_rss_hash(const struct dp_packet *p)



    >> {



    >>     return *dp_packet_rss_ptr(p);



    >> }



    >>



    >> static inline ovs_be16



    >> netdev_tnl_get_src_port(struct dp_packet *packet)



    >> {



    >>     uint32_t hash;



    >>



    >>     hash = dp_packet_get_rss_hash(packet);



    >>



    >>     return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +



    >>                  tnl_udp_port_min);



    >> }



    >>



    >> void



    >> netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,



    >>                            struct dp_packet *packet,



    >>                            const struct ovs_action_push_tnl *data)



    >> {



    >>     struct udp_header *udp;



    >>     int ip_tot_size;



    >>



    >>     udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);



    >>



    >>     /* set udp src port */



    >>     udp->udp_src = netdev_tnl_get_src_port(packet);



    >>     udp->udp_len = htons(ip_tot_size);



    >>



    >>     if (udp->udp_csum) {



    >>         netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);



    >>     }



    >> }



    >>



    >> This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The



    >> first fragment of original inner UDP is considered as different flow from other fragments.



    >>



    >> I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.



    >>



    >



    >You are right. I checked VxLAN RFC 7348, and outer source port is



    >calculated from inner packet. In OVS case, the first fragment



    >will have different outer source port compared with other fragments.



    >Please add some comments in the code for people to better understand



    >the code. In addition, need to remove outer_src_port from the structure



    >vxlan_udp4_flow_key.



    >



    >> >



    >> >> +    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,



    >> >> +                                    &k2.outer_eth_saddr) &&



    >> >> +                    rte_is_same_ether_addr(&k1.outer_eth_daddr,



    >> >> +                            &k2.outer_eth_daddr) &&



    >> >> +                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&



    >> >> +                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&



    >> >> +                    (k1.outer_dst_port == k2.outer_dst_port) &&



    >> >> +                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&



    >> >> +                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&



    >> >> +                    is_same_udp4_flow(k1.inner_key, k2.inner_key));



    >> >> +}



    >> >> +



    >> >> +static inline int



    >> >> +udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,



    >> >> +            uint16_t frag_offset,



    >> >> +            uint16_t ip_dl)



    >> >



    >> >Better rename it as udp4_check_vxlan_neighbor.



    >>



    >> Ok



    >>



    >> >



    >> >> +{



    >> >> +    struct rte_mbuf *pkt = item->inner_item.firstseg;



    >> >> +    int cmp;



    >> >> +    uint16_t l2_offset;



    >> >> +    int ret = 0;



    >> >> +



    >> >> +    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;



    >> >> +    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,



    >> >> +                                    l2_offset);



    >> >



    >> >Why don't check outer IP ID? If outer DF bit is not set, all fragments



    >> >should have incremental outer IP ID; if DF bit is set, we don't need



    >> >to check outer IP ID.



    >>



    >> By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check



    >> is enough to differentiate if they are same flow, isn't it?



    >



    >OVS is one of workloads using DPDK, and we can assume



    >other cases have the same design as OVS. I think IP ID



    >check is necessary.



    >



    >>



    >> >



    >> >In addition, udp_check_neighbor is renamed, but you didn't change here.



    >>



    >> Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will



    >> use meson build to check it for next version.



    >>



    >> >



    >> >> +    /* VXLAN outer IP ID is out of order, so don't touch it and



    >> >> +     * don't compare it.



    >> >> +     */



    >> >> +    if (cmp > 0)



    >> >> +            /* Append the new packet. */



    >> >> +            ret = 1;



    >> >> +    else if (cmp < 0)



    >> >> +            /* Prepend the new packet. */



    >> >> +            ret = -1;



    >> >> +



    >> >> +    return ret;



    >> >> +}



    >> >> +



    >> >>



    >> >>  /*



    >> >>   * GRO context structure. It keeps the table structures, which are



    >> >> @@ -137,19 +148,27 @@ struct gro_ctx {



    >> >>      struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };



    >> >>



    >> >>      /* Allocate a reassembly table for VXLAN TCP GRO */



    >> >> -    struct gro_vxlan_tcp4_tbl vxlan_tbl;



    >> >> -    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];



    >> >> -    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]



    >> >> +    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;



    >> >> +    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];



    >> >> +    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]



    >> >> +                    = {{{0}, 0, 0} };



    >> >> +



    >> >> +    /* Allocate a reassembly table for VXLAN UDP GRO */



    >> >> +    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;



    >> >> +    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];



    >> >> +    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]



    >> >>                      = {{{0}, 0, 0} };



    >> >>



    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];



    >> >>      uint32_t item_num;



    >> >>      int32_t ret;



    >> >>      uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;



    >> >> -    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;



    >> >> +    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,



    >> >> +            do_vxlan_udp_gro = 0;



    >> >>



    >> >>      if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |



    >> >>                                      RTE_GRO_TCP_IPV4 |



    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |



    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))



    >> >>              return nb_pkts;



    >> >>



    >> >> @@ -160,15 +179,28 @@ struct gro_ctx {



    >> >>



    >> >>      if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {



    >> >>              for (i = 0; i < item_num; i++)



    >> >> -                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;



    >> >> -



    >> >> -            vxlan_tbl.flows = vxlan_flows;



    >> >> -            vxlan_tbl.items = vxlan_items;



    >> >> -            vxlan_tbl.flow_num = 0;



    >> >> -            vxlan_tbl.item_num = 0;



    >> >> -            vxlan_tbl.max_flow_num = item_num;



    >> >> -            vxlan_tbl.max_item_num = item_num;



    >> >> -            do_vxlan_gro = 1;



    >> >> +                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;



    >> >> +



    >> >> +            vxlan_tcp_tbl.flows = vxlan_tcp_flows;



    >> >> +            vxlan_tcp_tbl.items = vxlan_tcp_items;



    >> >> +            vxlan_tcp_tbl.flow_num = 0;



    >> >> +            vxlan_tcp_tbl.item_num = 0;



    >> >> +            vxlan_tcp_tbl.max_flow_num = item_num;



    >> >> +            vxlan_tcp_tbl.max_item_num = item_num;



    >> >> +            do_vxlan_tcp_gro = 1;



    >> >> +    }



    >> >> +



    >> >> +    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {



    >> >> +            for (i = 0; i < item_num; i++)



    >> >> +                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;



    >> >> +



    >> >> +            vxlan_udp_tbl.flows = vxlan_udp_flows;



    >> >> +            vxlan_udp_tbl.items = vxlan_udp_items;



    >> >> +            vxlan_udp_tbl.flow_num = 0;



    >> >> +            vxlan_udp_tbl.item_num = 0;



    >> >> +            vxlan_udp_tbl.max_flow_num = item_num;



    >> >> +            vxlan_udp_tbl.max_item_num = item_num;



    >> >> +            do_vxlan_udp_gro = 1;



    >> >>      }



    >> >>



    >> >>      if (param->gro_types & RTE_GRO_TCP_IPV4) {



    >> >> @@ -204,9 +236,18 @@ struct gro_ctx {



    >> >>               * will be flushed from the tables.



    >> >>               */



    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&



    >> >> -                            do_vxlan_gro) {



    >> >> +                            do_vxlan_tcp_gro) {



    >> >>                      ret = gro_vxlan_tcp4_reassemble(pkts[i],



    >> >> -                                                    &vxlan_tbl, 0);



    >> >> +                                                    &vxlan_tcp_tbl, 0);



    >> >> +                    if (ret > 0)



    >> >> +                            /* Merge successfully */



    >> >> +                            nb_after_gro--;



    >> >> +                    else if (ret < 0)



    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];



    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&



    >> >> +                            do_vxlan_udp_gro) {



    >> >> +                    ret = gro_vxlan_udp4_reassemble(pkts[i],



    >> >> +                                                    &vxlan_udp_tbl, 0);



    >> >>                      if (ret > 0)



    >> >>                              /* Merge successfully */



    >> >>                              nb_after_gro--;



    >> >> @@ -236,11 +277,17 @@ struct gro_ctx {



    >> >>               || (unprocess_num < nb_pkts)) {



    >> >>              i = 0;



    >> >>              /* Flush all packets from the tables */



    >> >> -            if (do_vxlan_gro) {



    >> >> -                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,



    >> >> +            if (do_vxlan_tcp_gro) {



    >> >> +                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,



    >> >>                                      0, pkts, nb_pkts);



    >> >>              }



    >> >>



    >> >> +            if (do_vxlan_udp_gro) {



    >> >> +                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,



    >> >> +                                    0, &pkts[i], nb_pkts - i);



    >> >> +



    >> >> +            }



    >> >> +



    >> >>              if (do_tcp4_gro) {



    >> >>                      i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,



    >> >>                                      &pkts[i], nb_pkts - i);



    >> >> @@ -269,33 +316,42 @@ struct gro_ctx {



    >> >>  {



    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];



    >> >>      struct gro_ctx *gro_ctx = ctx;



    >> >> -    void *tcp_tbl, *udp_tbl, *vxlan_tbl;



    >> >> +    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;



    >> >>      uint64_t current_time;



    >> >>      uint16_t i, unprocess_num = 0;



    >> >> -    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;



    >> >> +    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;



    >> >>



    >> >>      if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |



    >> >>                                      RTE_GRO_TCP_IPV4 |



    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |



    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))



    >> >>              return nb_pkts;



    >> >>



    >> >>      tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];



    >> >> -    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];



    >> >> +    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];



    >> >>      udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];



    >> >> +    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];



    >> >>



    >> >>      do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==



    >> >>              RTE_GRO_TCP_IPV4;



    >> >> -    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==



    >> >> +    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==



    >> >>              RTE_GRO_IPV4_VXLAN_TCP_IPV4;



    >> >>      do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==



    >> >>              RTE_GRO_UDP_IPV4;



    >> >> +    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==



    >> >> +            RTE_GRO_IPV4_VXLAN_UDP_IPV4;



    >> >>



    >> >>      current_time = rte_rdtsc();



    >> >>



    >> >>      for (i = 0; i < nb_pkts; i++) {



    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&



    >> >> -                            do_vxlan_gro) {



    >> >> -                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,



    >> >> +                            do_vxlan_tcp_gro) {



    >> >> +                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,



    >> >> +                                            current_time) < 0)



    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];



    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&



    >> >> +                            do_vxlan_udp_gro) {



    >> >> +                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,



    >> >>                                              current_time) < 0)



    >> >>                              unprocess_pkts[unprocess_num++] = pkts[i];



    >> >>              } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&



    >> >> @@ -341,6 +397,13 @@ struct gro_ctx {



    >> >>              left_nb_out = max_nb_out - num;



    >> >>      }



    >> >>



    >> >> +    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {



    >> >> +            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[



    >> >> +                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],



    >> >> +                            flush_timestamp, &out[num], left_nb_out);



    >> >> +            left_nb_out = max_nb_out - num;



    >> >



    >> >Don't need to calculate left_nb_out here. In the previous patch, you



    >> >also calculate it for UDP GRO. Please remove it both.



    >>



    >> I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.



    >



    >I don't think so. It's unnecessary for current design.



    >If others want to add new GRO types, they will write



    >correct code.



    >



    >>



    >> >



    >>



    >>



    >>



    >>



    >>
author
#14 lore raw

Re: [dpdk-dev] [PATCH v5 2/2] gro: add VXLAN UDP GRO support

Thanks Jiayu, will add comments to explain it in v5.

At 2020-09-17 10:06:37, "Hu, Jiayu" <[email protected]> wrote:

OK, I agree to ignore processing outer IP ID. But I think the comment need to change, as

it is not accurate. VxLAN/UDP GRO doesn’t process outer IP ID is because it is meaningless

for reassembly in the ovs case you mentioned, rather than it’s out-of-order. You can

give the ovs example in the commit log, and it’s easier to understand the code IMO.

Thanks,

Jiayu

From: yang_y_yi <[email protected]>
Sent: Wednesday, September 16, 2020 11:06 AM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: RE: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
Importance: High

No, next_proto_id of inner IP header can clearly identify it is a UDP packet even if it is a no-udp-header ip fragment.

Quoted 1,258 lines · Jiayu Hu
Quoted 9 lines · yang_y_yi

Jiayu, VM to VM case for big UDP packet (say udp parload size is 8192K, but mtu 1500). VM will segment it as UDP framgments, but when ovs dpdk uses VxLan to encapsulate them, it doesn't know they are same flow, OVS DPDK has no knowldge about them, just encapsulate them as if they are not related. But on receive side on another machine, OVS DPDK will GRO them, at this point, outer IP ID is even random for every packet. For TCP, I think same issue is there, GRO just considered them as different flow and doesn't do GRO, in my opinion, we also should do GRO for such case.

I am a little confused about ovs behavior. Does ovs know they are udp fragments? Or it knows they are fragments but doesn't know they are from one flow? Given ovs receives 3 udp fragments of a udp packet, if ovs doesn't know they are fragments of a udp packet, their mbuf->packet_type will be ether/ipv4/udp, ether/ipv4, and ether/ipv4. dpdk udp gro will not process the second and third one as their packet type in mbuf is not ether/ipv4/udp.

Quoted 1,240 lines

   2020-09-14 16:50:08  "Hu, Jiayu" <[email protected]> д    
    Out IP ID is not used to check if they belong to the same flow,

    but check if they are neighbors. If two vxlan/udp fragments are

    neighbors, their outer IP ID and outer frag_oft should be incremental.

    I still cannot understand why ignore outer IP ID when DF is 0.

    Can you give more explanation?

     

    From: yang_y_yi <[email protected]>
    Sent: Monday, September 14, 2020 4:27 PM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: Re: [PATCH v5 2/2] gro: add VXLAN UDP GRO support
    Importance: High

     

    For outer_ip_id, there is same ip_id disorder issue existing as UDP GRO, so
    we can't use ip_id +/-1 to check if they are same flow, here is my
    incrmental change for it with more comments.

     

    @@ -189,7 +188,12 @@
     is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,
                    struct vxlan_udp4_flow_key k2)
     {
    -       /* src port is changing, so shouldn't use it for flow check */
    +       /* For VxLAN packet, outer udp src port is calculated from
    +        * inner packet RSS hash, udp src port of the first UDP
    +        * fragment is different from one of other UDP fragments
    +        * even if they are same flow, so we have to skip outer udp
    +        * src port comparison here.
    +        */
            return (rte_is_same_ether_addr(&k1.outer_eth_saddr,
                                            &k2.outer_eth_saddr) &&
                            rte_is_same_ether_addr(&k1.outer_eth_daddr,
    @@ -212,12 +216,16 @@
            uint16_t l2_offset;
            int ret = 0;

    +       /* Note: if outer DF bit is set, i.e outer_is_atomic is 0,
    +        * we needn't compare outer_ip_id because they are same,
    +        * for the case outer_is_atomic is 1, we also have no way
    +        * to comapre outer_ip_id because the received packets can
    +        * be out of order. So ignore outer_ip_id comparison here.
    +        */
    +
            l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;
            cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,
                                            l2_offset);
    -       /* VXLAN outer IP ID is out of order, so don't touch it and
    -        * don't compare it.
    -        */
            if (cmp > 0)
                    /* Append the new packet. */
                    ret = 1;
    @@ -354,7 +362,9 @@
            rte_ether_addr_copy(&(outer_eth_hdr->d_addr), &
    (key.outer_eth_daddr));
            key.outer_ip_src_addr = outer_ipv4_hdr->src_addr;
            key.outer_ip_dst_addr = outer_ipv4_hdr->dst_addr;
    -       key.outer_src_port = udp_hdr->src_port;
    +       /* Note: It is unnecessary to save outer_src_port here because it
    can
    +        * be different for VxLAN UDP fragments from the same flow.
    +        */
            key.outer_dst_port = udp_hdr->dst_port;

            /* Search for a matched flow. */

     

     

     

    
    At 2020-09-14 12:21:26, "Jiayu Hu" <[email protected]> wrote:

    >Replies are inline.

    > 

    >BTW, you need to update the programmer guide

    >doc/guides/prog_guide/generic_receive_offload_lib.rst and

    >release note doc/guides/rel_notes/release_20_11.rst.

    > 

    >Thanks,

    >Jiayu

    > 

    >On Mon, Sep 14, 2020 at 10:13:44AM +0800, yang_y_yi wrote:

    >> Jiayu, thank you so much, please check my replies for some of your comments,

    >> here is incremental patch. I built it by meson this time :-)

    >> 

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> index 9e9df72..1fcfaf1 100644

    >> --- a/lib/librte_gro/gro_vxlan_udp4.c

    >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> @@ -203,7 +203,7 @@

    >>  }

    >> 

    >>  static inline int

    >> -udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> +udp4_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >>                 uint16_t frag_offset,

    >>                 uint16_t ip_dl)

    >>  {

    >> @@ -213,7 +213,7 @@

    >>         int ret = 0;

    >> 

    >>         l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> -       cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> +       cmp = udp4_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >>                                         l2_offset);

    >>         /* VXLAN outer IP ID is out of order, so don't touch it and

    >>          * don't compare it.

    >> @@ -379,7 +379,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 if (insert_new_flow(tbl, &key, item_idx) ==

    >>                                 INVALID_ARRAY_INDEX) {

    >> @@ -397,7 +397,7 @@

    >>         cur_idx = tbl->flows[i].start_index;

    >>         prev_idx = cur_idx;

    >>         do {

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[cur_idx]),

    >>                                 frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -436,7 +436,7 @@

    >>                 item_idx = insert_new_item(tbl, pkt, start_time,

    >>                                 INVALID_ARRAY_INDEX, frag_offset,

    >>                                 is_last_frag, outer_ip_id, outer_is_atomic);

    >> -               if (item_idx == INVALID_ARRAY_INDEX)

    >> +               if (unlikely(item_idx == INVALID_ARRAY_INDEX))

    >>                         return -1;

    >>                 tbl->items[item_idx].inner_item.next_pkt_idx = cur_idx;

    >>                 tbl->flows[i].start_index = item_idx;

    >> @@ -470,7 +470,7 @@

    >>                 ip_dl = pkt->pkt_len - hdr_len;

    >>                 frag_offset = tbl->items[item_idx].inner_item.frag_offset;

    >>                 is_last_frag = tbl->items[item_idx].inner_item.is_last_frag;

    >> -               cmp = udp_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >> +               cmp = udp4_check_vxlan_neighbor(&(tbl->items[start_idx]),

    >>                                         frag_offset, ip_dl);

    >>                 if (cmp) {

    >>                         if (merge_two_vxlan_udp4_packets(

    >> @@ -481,12 +481,10 @@

    >>                                                         INVALID_ARRAY_INDEX);

    >>                                 tbl->items[start_idx].inner_item.next_pkt_idx

    >>                                         = item_idx;

    >> -                       } else {

    >> +                       } else

    >>                                 return 0;

    >> -                       }

    >> -               } else {

    >> +               } else

    >>                         return 0;

    >> -               }

    >>         }

    >> 

    >>         return 0;

    >> 

    >> 

    >> At 2020-09-11 12:24:16, "Jiayu Hu" <[email protected]> wrote:

    >> >Some comments are inline.

    >> >

    >> >Thanks,

    >> >Jiayu

    >> >

    >> >On Thu, Sep 10, 2020 at 05:29:14PM +0800, [email protected] wrote:

    >> >> From: Yi Yang <[email protected]>

    >> >>

    >> >> VXLAN UDP GRO can help improve VM-to-VM UDP performance

    >> >> when VM is enabled UFO or GSO, GRO must be supported if

    >> >> GSO or UFO is enabled, otherwise, performance gain will

    >> >> be hurt.

    >> >>

    >> >> With this enabled in DPDK, OVS DPDK can leverage it to

    >> >> improve VM-to-VM UDP performance, this will make sure

    >> >> IP fragments will be reassembled once it is received

    >> >> from physical NIC. It is very helpful in OVS DPDK VXLAN

    >> >> TSO case.

    >> >>

    >> >> Signed-off-by: Yi Yang <[email protected]>

    >> >> ---

    >> >>  lib/librte_gro/gro_udp4.h       |   1 +

    >> >>  lib/librte_gro/gro_vxlan_udp4.c | 548 ++++++++++++++++++++++++++++++++++++++++

    >> >>  lib/librte_gro/gro_vxlan_udp4.h | 152 +++++++++++

    >> >>  lib/librte_gro/meson.build      |   2 +-

    >> >>  lib/librte_gro/rte_gro.c        | 115 +++++++--

    >> >>  lib/librte_gro/rte_gro.h        |   3 +

    >> >>  6 files changed, 794 insertions(+), 27 deletions(-)

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.c

    >> >>  create mode 100644 lib/librte_gro/gro_vxlan_udp4.h

    >> >>

    >> >> diff --git a/lib/librte_gro/gro_udp4.h b/lib/librte_gro/gro_udp4.h

    >> >> index 0a078e4..d38b393 100644

    >> >> --- a/lib/librte_gro/gro_udp4.h

    >> >> +++ b/lib/librte_gro/gro_udp4.h

    >> >> @@ -7,6 +7,7 @@

    >> >>

    >> >>  #include <rte_ip.h>

    >> >>  #include <rte_udp.h>

    >> >> +#include <rte_vxlan.h>

    >> >>

    >> >>  #define INVALID_ARRAY_INDEX 0xffffffffUL

    >> >>  #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)

    >> >> diff --git a/lib/librte_gro/gro_vxlan_udp4.c b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> new file mode 100644

    >> >> index 0000000..9e9df72

    >> >> --- /dev/null

    >> >> +++ b/lib/librte_gro/gro_vxlan_udp4.c

    >> >> @@ -0,0 +1,548 @@

    >> >> +/* SPDX-License-Identifier: BSD-3-Clause

    >> >> + * Copyright(c) 2020 Inspur Corporation

    >> >> + */

    >> >> +

    >> >> +

    >> >> +

    >> >> +static inline uint32_t

    >> >> +delete_item(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            uint32_t item_idx,

    >> >> +            uint32_t prev_item_idx)

    >> >> +{

    >> >> +    uint32_t next_idx = tbl->items[item_idx].inner_item.next_pkt_idx;

    >> >> +

    >> >> +    /* NULL indicates an empty item. */

    >> >> +    tbl->items[item_idx].inner_item.firstseg = NULL;

    >> >> +    tbl->item_num--;

    >> >> +    if (prev_item_idx != INVALID_ARRAY_INDEX)

    >> >> +            tbl->items[prev_item_idx].inner_item.next_pkt_idx = next_idx;

    >> >> +

    >> >> +    return next_idx;

    >> >> +}

    >> >> +

    >> >> +static inline uint32_t

    >> >> +insert_new_flow(struct gro_vxlan_udp4_tbl *tbl,

    >> >> +            struct vxlan_udp4_flow_key *src,

    >> >> +            uint32_t item_idx)

    >> >> +{

    >> >> +    struct vxlan_udp4_flow_key *dst;

    >> >> +    uint32_t flow_idx;

    >> >> +

    >> >> +    flow_idx = find_an_empty_flow(tbl);

    >> >> +    if (unlikely(flow_idx == INVALID_ARRAY_INDEX))

    >> >> +            return INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +    dst = &(tbl->flows[flow_idx].key);

    >> >> +

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_saddr),

    >> >> +                    &(dst->inner_key.eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->inner_key.eth_daddr),

    >> >> +                    &(dst->inner_key.eth_daddr));

    >> >> +    dst->inner_key.ip_src_addr = src->inner_key.ip_src_addr;

    >> >> +    dst->inner_key.ip_dst_addr = src->inner_key.ip_dst_addr;

    >> >> +    dst->inner_key.ip_id = src->inner_key.ip_id;

    >> >> +

    >> >> +    dst->vxlan_hdr.vx_flags = src->vxlan_hdr.vx_flags;

    >> >> +    dst->vxlan_hdr.vx_vni = src->vxlan_hdr.vx_vni;

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_saddr), &(dst->outer_eth_saddr));

    >> >> +    rte_ether_addr_copy(&(src->outer_eth_daddr), &(dst->outer_eth_daddr));

    >> >> +    dst->outer_ip_src_addr = src->outer_ip_src_addr;

    >> >> +    dst->outer_ip_dst_addr = src->outer_ip_dst_addr;

    >> >> +    dst->outer_src_port = src->outer_src_port;

    >> >> +    dst->outer_dst_port = src->outer_dst_port;

    >> >> +

    >> >> +    tbl->flows[flow_idx].start_index = item_idx;

    >> >> +    tbl->flow_num++;

    >> >> +

    >> >> +    return flow_idx;

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +is_same_vxlan_udp4_flow(struct vxlan_udp4_flow_key k1,

    >> >> +            struct vxlan_udp4_flow_key k2)

    >> >> +{

    >> >> +    /* src port is changing, so shouldn't use it for flow check */

    >> >

    >> >As I know, fragments of a vxlan/udp/ipv4 packet have same outer source

    >> >port. In what cases outer source port will change?

    >> 

    >> In OVS, vxlan udp soure port is calculated from inner packet RSS, so for UDP fragment, RSS of first packet is

    >> different from other fragments because RSS is calculated based on 5 tuples (src ip, src port, dst ip, dst port,

    >> protocol type).

    >> 

    >> ovs/lib/netdev-native-tnl.h:

    >> 

    >> static inline uint32_t *

    >> dp_packet_rss_ptr(const struct dp_packet *b)

    >> {

    >>     return CONST_CAST(uint32_t *, &b->mbuf.hash.rss);

    >> }

    >> 

    >> static inline uint32_t

    >> dp_packet_get_rss_hash(const struct dp_packet *p)

    >> {

    >>     return *dp_packet_rss_ptr(p);

    >> }

    >> 

    >> static inline ovs_be16

    >> netdev_tnl_get_src_port(struct dp_packet *packet)

    >> {

    >>     uint32_t hash;

    >> 

    >>     hash = dp_packet_get_rss_hash(packet);

    >> 

    >>     return htons((((uint64_t) hash * (tnl_udp_port_max - tnl_udp_port_min)) >> 32) +

    >>                  tnl_udp_port_min);

    >> }

    >> 

    >> void

    >> netdev_tnl_push_udp_header(const struct netdev *netdev OVS_UNUSED,

    >>                            struct dp_packet *packet,

    >>                            const struct ovs_action_push_tnl *data)

    >> {

    >>     struct udp_header *udp;

    >>     int ip_tot_size;

    >> 

    >>     udp = netdev_tnl_push_ip_header(packet, data->header, data->header_len, &ip_tot_size);

    >> 

    >>     /* set udp src port */

    >>     udp->udp_src = netdev_tnl_get_src_port(packet);

    >>     udp->udp_len = htons(ip_tot_size);

    >> 

    >>     if (udp->udp_csum) {

    >>         netdev_tnl_calc_udp_csum(udp, packet, ip_tot_size);

    >>     }

    >> }

    >> 

    >> This is special for ECMP which only checks outer header to differentiate different flows (innner packet). The

    >> first fragment of original inner UDP is considered as different flow from other fragments.

    >> 

    >> I found this by debugging becuase the same UDP traffic did generate different vxlan UDP source port.

    >> 

    > 

    >You are right. I checked VxLAN RFC 7348, and outer source port is

    >calculated from inner packet. In OVS case, the first fragment

    >will have different outer source port compared with other fragments.

    >Please add some comments in the code for people to better understand

    >the code. In addition, need to remove outer_src_port from the structure

    >vxlan_udp4_flow_key.

    > 

    >> >

    >> >> +    return (rte_is_same_ether_addr(&k1.outer_eth_saddr,

    >> >> +                                    &k2.outer_eth_saddr) &&

    >> >> +                    rte_is_same_ether_addr(&k1.outer_eth_daddr,

    >> >> +                            &k2.outer_eth_daddr) &&

    >> >> +                    (k1.outer_ip_src_addr == k2.outer_ip_src_addr) &&

    >> >> +                    (k1.outer_ip_dst_addr == k2.outer_ip_dst_addr) &&

    >> >> +                    (k1.outer_dst_port == k2.outer_dst_port) &&

    >> >> +                    (k1.vxlan_hdr.vx_flags == k2.vxlan_hdr.vx_flags) &&

    >> >> +                    (k1.vxlan_hdr.vx_vni == k2.vxlan_hdr.vx_vni) &&

    >> >> +                    is_same_udp4_flow(k1.inner_key, k2.inner_key));

    >> >> +}

    >> >> +

    >> >> +static inline int

    >> >> +udp_check_vxlan_neighbor(struct gro_vxlan_udp4_item *item,

    >> >> +            uint16_t frag_offset,

    >> >> +            uint16_t ip_dl)

    >> >

    >> >Better rename it as udp4_check_vxlan_neighbor.

    >> 

    >> Ok

    >> 

    >> >

    >> >> +{

    >> >> +    struct rte_mbuf *pkt = item->inner_item.firstseg;

    >> >> +    int cmp;

    >> >> +    uint16_t l2_offset;

    >> >> +    int ret = 0;

    >> >> +

    >> >> +    l2_offset = pkt->outer_l2_len + pkt->outer_l3_len;

    >> >> +    cmp = udp_check_neighbor(&item->inner_item, frag_offset, ip_dl,

    >> >> +                                    l2_offset);

    >> >

    >> >Why don't check outer IP ID? If outer DF bit is not set, all fragments

    >> >should have incremental outer IP ID; if DF bit is set, we don't need

    >> >to check outer IP ID.

    >> 

    >> By default, OVS set DF flag. I don't think we need to compare outer IP id because inner check

    >> is enough to differentiate if they are same flow, isn't it?

    > 

    >OVS is one of workloads using DPDK, and we can assume

    >other cases have the same design as OVS. I think IP ID

    >check is necessary.

    > 

    >> 

    >> >

    >> >In addition, udp_check_neighbor is renamed, but you didn't change here.

    >> 

    >> Forgot to build it, Makefile has been removed from dpdk main branch, build isn't so convinient, will

    >> use meson build to check it for next version.

    >> 

    >> >

    >> >> +    /* VXLAN outer IP ID is out of order, so don't touch it and

    >> >> +     * don't compare it.

    >> >> +     */

    >> >> +    if (cmp > 0)

    >> >> +            /* Append the new packet. */

    >> >> +            ret = 1;

    >> >> +    else if (cmp < 0)

    >> >> +            /* Prepend the new packet. */

    >> >> +            ret = -1;

    >> >> +

    >> >> +    return ret;

    >> >> +}

    >> >> +

    >> >>

    >> >>  /*

    >> >>   * GRO context structure. It keeps the table structures, which are

    >> >> @@ -137,19 +148,27 @@ struct gro_ctx {

    >> >>      struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };

    >> >>

    >> >>      /* Allocate a reassembly table for VXLAN TCP GRO */

    >> >> -    struct gro_vxlan_tcp4_tbl vxlan_tbl;

    >> >> -    struct gro_vxlan_tcp4_flow vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> -    struct gro_vxlan_tcp4_item vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;

    >> >> +    struct gro_vxlan_tcp4_flow vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_tcp4_item vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >> +                    = {{{0}, 0, 0} };

    >> >> +

    >> >> +    /* Allocate a reassembly table for VXLAN UDP GRO */

    >> >> +    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;

    >> >> +    struct gro_vxlan_udp4_flow vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

    >> >> +    struct gro_vxlan_udp4_item vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

    >> >>                      = {{{0}, 0, 0} };

    >> >>

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      uint32_t item_num;

    >> >>      int32_t ret;

    >> >>      uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;

    >> >> -    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;

    >> >> +    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,

    >> >> +            do_vxlan_udp_gro = 0;

    >> >>

    >> >>      if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >> @@ -160,15 +179,28 @@ struct gro_ctx {

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {

    >> >>              for (i = 0; i < item_num; i++)

    >> >> -                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> -

    >> >> -            vxlan_tbl.flows = vxlan_flows;

    >> >> -            vxlan_tbl.items = vxlan_items;

    >> >> -            vxlan_tbl.flow_num = 0;

    >> >> -            vxlan_tbl.item_num = 0;

    >> >> -            vxlan_tbl.max_flow_num = item_num;

    >> >> -            vxlan_tbl.max_item_num = item_num;

    >> >> -            do_vxlan_gro = 1;

    >> >> +                    vxlan_tcp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_tcp_tbl.flows = vxlan_tcp_flows;

    >> >> +            vxlan_tcp_tbl.items = vxlan_tcp_items;

    >> >> +            vxlan_tcp_tbl.flow_num = 0;

    >> >> +            vxlan_tcp_tbl.item_num = 0;

    >> >> +            vxlan_tcp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_tcp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_tcp_gro = 1;

    >> >> +    }

    >> >> +

    >> >> +    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {

    >> >> +            for (i = 0; i < item_num; i++)

    >> >> +                    vxlan_udp_flows[i].start_index = INVALID_ARRAY_INDEX;

    >> >> +

    >> >> +            vxlan_udp_tbl.flows = vxlan_udp_flows;

    >> >> +            vxlan_udp_tbl.items = vxlan_udp_items;

    >> >> +            vxlan_udp_tbl.flow_num = 0;

    >> >> +            vxlan_udp_tbl.item_num = 0;

    >> >> +            vxlan_udp_tbl.max_flow_num = item_num;

    >> >> +            vxlan_udp_tbl.max_item_num = item_num;

    >> >> +            do_vxlan_udp_gro = 1;

    >> >>      }

    >> >>

    >> >>      if (param->gro_types & RTE_GRO_TCP_IPV4) {

    >> >> @@ -204,9 +236,18 @@ struct gro_ctx {

    >> >>               * will be flushed from the tables.

    >> >>               */

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> +                            do_vxlan_tcp_gro) {

    >> >>                      ret = gro_vxlan_tcp4_reassemble(pkts[i],

    >> >> -                                                    &vxlan_tbl, 0);

    >> >> +                                                    &vxlan_tcp_tbl, 0);

    >> >> +                    if (ret > 0)

    >> >> +                            /* Merge successfully */

    >> >> +                            nb_after_gro--;

    >> >> +                    else if (ret < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    ret = gro_vxlan_udp4_reassemble(pkts[i],

    >> >> +                                                    &vxlan_udp_tbl, 0);

    >> >>                      if (ret > 0)

    >> >>                              /* Merge successfully */

    >> >>                              nb_after_gro--;

    >> >> @@ -236,11 +277,17 @@ struct gro_ctx {

    >> >>               || (unprocess_num < nb_pkts)) {

    >> >>              i = 0;

    >> >>              /* Flush all packets from the tables */

    >> >> -            if (do_vxlan_gro) {

    >> >> -                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,

    >> >> +            if (do_vxlan_tcp_gro) {

    >> >> +                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,

    >> >>                                      0, pkts, nb_pkts);

    >> >>              }

    >> >>

    >> >> +            if (do_vxlan_udp_gro) {

    >> >> +                    i += gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,

    >> >> +                                    0, &pkts[i], nb_pkts - i);

    >> >> +

    >> >> +            }

    >> >> +

    >> >>              if (do_tcp4_gro) {

    >> >>                      i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,

    >> >>                                      &pkts[i], nb_pkts - i);

    >> >> @@ -269,33 +316,42 @@ struct gro_ctx {

    >> >>  {

    >> >>      struct rte_mbuf *unprocess_pkts[nb_pkts];

    >> >>      struct gro_ctx *gro_ctx = ctx;

    >> >> -    void *tcp_tbl, *udp_tbl, *vxlan_tbl;

    >> >> +    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;

    >> >>      uint64_t current_time;

    >> >>      uint16_t i, unprocess_num = 0;

    >> >> -    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;

    >> >> +    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro, do_vxlan_udp_gro;

    >> >>

    >> >>      if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |

    >> >>                                      RTE_GRO_TCP_IPV4 |

    >> >> +                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |

    >> >>                                      RTE_GRO_UDP_IPV4)) == 0))

    >> >>              return nb_pkts;

    >> >>

    >> >>      tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];

    >> >> -    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >> +    vxlan_tcp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

    >> >>      udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];

    >> >> +    vxlan_udp_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

    >> >>

    >> >>      do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==

    >> >>              RTE_GRO_TCP_IPV4;

    >> >> -    do_vxlan_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >> +    do_vxlan_tcp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

    >> >>              RTE_GRO_IPV4_VXLAN_TCP_IPV4;

    >> >>      do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==

    >> >>              RTE_GRO_UDP_IPV4;

    >> >> +    do_vxlan_udp_gro = (gro_ctx->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

    >> >> +            RTE_GRO_IPV4_VXLAN_UDP_IPV4;

    >> >>

    >> >>      current_time = rte_rdtsc();

    >> >>

    >> >>      for (i = 0; i < nb_pkts; i++) {

    >> >>              if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&

    >> >> -                            do_vxlan_gro) {

    >> >> -                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,

    >> >> +                            do_vxlan_tcp_gro) {

    >> >> +                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,

    >> >> +                                            current_time) < 0)

    >> >> +                            unprocess_pkts[unprocess_num++] = pkts[i];

    >> >> +            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&

    >> >> +                            do_vxlan_udp_gro) {

    >> >> +                    if (gro_vxlan_udp4_reassemble(pkts[i], vxlan_udp_tbl,

    >> >>                                              current_time) < 0)

    >> >>                              unprocess_pkts[unprocess_num++] = pkts[i];

    >> >>              } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

    >> >> @@ -341,6 +397,13 @@ struct gro_ctx {

    >> >>              left_nb_out = max_nb_out - num;

    >> >>      }

    >> >>

    >> >> +    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out > 0) {

    >> >> +            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[

    >> >> +                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],

    >> >> +                            flush_timestamp, &out[num], left_nb_out);

    >> >> +            left_nb_out = max_nb_out - num;

    >> >

    >> >Don't need to calculate left_nb_out here. In the previous patch, you

    >> >also calculate it for UDP GRO. Please remove it both.

    >> 

    >> I think keeping it here isn't bad thing, if someone will add a new GRO type here, he/she won't make a mistake.

    > 

    >I don't think so. It's unnecessary for current design.

    >If others want to add new GRO types, they will write

    >correct code.

    > 

    >> 

    >> >

    >> 

    >> 

    >> 

    >>  

    >>