X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_gro%2Frte_gro.c;h=6618f4d32dbed8ab8c893597412116cb11054f5b;hb=5b9656b157d3fefb9076f2ba8c72490dacdb7242;hp=0b648665dbb08676c76fa2bb634304c424f56fa9;hpb=1e4cf4d6d4fb9786d2b0772867f2158ac90f55d6;p=dpdk.git

diff --git a/lib/librte_gro/rte_gro.c b/lib/librte_gro/rte_gro.c
index 0b648665db..6618f4d32d 100644
--- a/lib/librte_gro/rte_gro.c
+++ b/lib/librte_gro/rte_gro.c
@@ -9,6 +9,7 @@
 
 #include "rte_gro.h"
 #include "gro_tcp4.h"
+#include "gro_vxlan_tcp4.h"
 
 typedef void *(*gro_tbl_create_fn)(uint16_t socket_id,
 		uint16_t max_flow_num,
@@ -17,15 +18,28 @@ typedef void (*gro_tbl_destroy_fn)(void *tbl);
 typedef uint32_t (*gro_tbl_pkt_count_fn)(void *tbl);
 
 static gro_tbl_create_fn tbl_create_fn[RTE_GRO_TYPE_MAX_NUM] = {
-		gro_tcp4_tbl_create, NULL};
+		gro_tcp4_tbl_create, gro_vxlan_tcp4_tbl_create, NULL};
 static gro_tbl_destroy_fn tbl_destroy_fn[RTE_GRO_TYPE_MAX_NUM] = {
-			gro_tcp4_tbl_destroy, NULL};
+			gro_tcp4_tbl_destroy, gro_vxlan_tcp4_tbl_destroy,
+			NULL};
 static gro_tbl_pkt_count_fn tbl_pkt_count_fn[RTE_GRO_TYPE_MAX_NUM] = {
-			gro_tcp4_tbl_pkt_count, NULL};
+			gro_tcp4_tbl_pkt_count, gro_vxlan_tcp4_tbl_pkt_count,
+			NULL};
 
 #define IS_IPV4_TCP_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \
 		((ptype & RTE_PTYPE_L4_TCP) == RTE_PTYPE_L4_TCP))
 
+#define IS_IPV4_VXLAN_TCP4_PKT(ptype) (RTE_ETH_IS_IPV4_HDR(ptype) && \
+		((ptype & RTE_PTYPE_L4_UDP) == RTE_PTYPE_L4_UDP) && \
+		((ptype & RTE_PTYPE_TUNNEL_VXLAN) == \
+		 RTE_PTYPE_TUNNEL_VXLAN) && \
+		 ((ptype & RTE_PTYPE_INNER_L4_TCP) == \
+		  RTE_PTYPE_INNER_L4_TCP) && \
+		  (((ptype & RTE_PTYPE_INNER_L3_MASK) & \
+		    (RTE_PTYPE_INNER_L3_IPV4 | \
+		     RTE_PTYPE_INNER_L3_IPV4_EXT | \
+		     RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN)) != 0))
+
 /*
  * GRO context structure. It keeps the table structures, which are
  * used to merge packets, for different GRO types. Before using
@@ -109,12 +123,20 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts,
 	struct gro_tcp4_flow tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
 	struct gro_tcp4_item tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM] = {{0} };
 
+	/* Allocate a reassembly table for VXLAN 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] = {
+		{{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;
 
-	if (unlikely((param->gro_types & RTE_GRO_TCP_IPV4) == 0))
+	if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
+					RTE_GRO_TCP_IPV4)) == 0))
 		return nb_pkts;
 
 	/* Get the maximum number of packets */
@@ -122,22 +144,47 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts,
 				param->max_item_per_flow));
 	item_num = RTE_MIN(item_num, RTE_GRO_MAX_BURST_ITEM_NUM);
 
-	for (i = 0; i < item_num; i++)
-		tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+	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;
+	}
 
-	tcp_tbl.flows = tcp_flows;
-	tcp_tbl.items = tcp_items;
-	tcp_tbl.flow_num = 0;
-	tcp_tbl.item_num = 0;
-	tcp_tbl.max_flow_num = item_num;
-	tcp_tbl.max_item_num = item_num;
+	if (param->gro_types & RTE_GRO_TCP_IPV4) {
+		for (i = 0; i < item_num; i++)
+			tcp_flows[i].start_index = INVALID_ARRAY_INDEX;
+
+		tcp_tbl.flows = tcp_flows;
+		tcp_tbl.items = tcp_items;
+		tcp_tbl.flow_num = 0;
+		tcp_tbl.item_num = 0;
+		tcp_tbl.max_flow_num = item_num;
+		tcp_tbl.max_item_num = item_num;
+		do_tcp4_gro = 1;
+	}
 
 	for (i = 0; i < nb_pkts; i++) {
-		if (IS_IPV4_TCP_PKT(pkts[i]->packet_type)) {
-			/*
-			 * The timestamp is ignored, since all packets
-			 * will be flushed from the tables.
-			 */
+		/*
+		 * The timestamp is ignored, since all packets
+		 * will be flushed from the tables.
+		 */
+		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_gro) {
+			ret = gro_vxlan_tcp4_reassemble(pkts[i], &vxlan_tbl, 0);
+			if (ret > 0)
+				/* Merge successfully */
+				nb_after_gro--;
+			else if (ret < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
+				do_tcp4_gro) {
 			ret = gro_tcp4_reassemble(pkts[i], &tcp_tbl, 0);
 			if (ret > 0)
 				/* merge successfully */
@@ -149,8 +196,16 @@ rte_gro_reassemble_burst(struct rte_mbuf **pkts,
 	}
 
 	if (nb_after_gro < nb_pkts) {
+		i = 0;
 		/* Flush all packets from the tables */
-		i = gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0, pkts, nb_pkts);
+		if (do_vxlan_gro) {
+			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+					0, pkts, nb_pkts);
+		}
+		if (do_tcp4_gro) {
+			i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
+					&pkts[i], nb_pkts - i);
+		}
 		/* Copy unprocessed packets */
 		if (unprocess_num > 0) {
 			memcpy(&pkts[i], unprocess_pkts,
@@ -169,18 +224,33 @@ rte_gro_reassemble(struct rte_mbuf **pkts,
 {
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	struct gro_ctx *gro_ctx = ctx;
-	void *tcp_tbl;
+	void *tcp_tbl, *vxlan_tbl;
 	uint64_t current_time;
 	uint16_t i, unprocess_num = 0;
+	uint8_t do_tcp4_gro, do_vxlan_gro;
 
-	if (unlikely((gro_ctx->gro_types & RTE_GRO_TCP_IPV4) == 0))
+	if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
+					RTE_GRO_TCP_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];
+
+	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) ==
+		RTE_GRO_IPV4_VXLAN_TCP_IPV4;
+
 	current_time = rte_rdtsc();
 
 	for (i = 0; i < nb_pkts; i++) {
-		if (IS_IPV4_TCP_PKT(pkts[i]->packet_type)) {
+		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_gro) {
+			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+						current_time) < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&
+				do_tcp4_gro) {
 			if (gro_tcp4_reassemble(pkts[i], tcp_tbl,
 						current_time) < 0)
 				unprocess_pkts[unprocess_num++] = pkts[i];
@@ -204,18 +274,27 @@ rte_gro_timeout_flush(void *ctx,
 {
 	struct gro_ctx *gro_ctx = ctx;
 	uint64_t flush_timestamp;
+	uint16_t num = 0;
 
 	gro_types = gro_types & gro_ctx->gro_types;
 	flush_timestamp = rte_rdtsc() - timeout_cycles;
 
-	if (gro_types & RTE_GRO_TCP_IPV4) {
-		return gro_tcp4_tbl_timeout_flush(
+	if (gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
+		num = gro_vxlan_tcp4_tbl_timeout_flush(gro_ctx->tbls[
+				RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX],
+				flush_timestamp, out, max_nb_out);
+		max_nb_out -= num;
+	}
+
+	/* If no available space in 'out', stop flushing. */
+	if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
+		num += gro_tcp4_tbl_timeout_flush(
 				gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX],
 				flush_timestamp,
-				out, max_nb_out);
+				&out[num], max_nb_out);
 	}
 
-	return 0;
+	return num;
 }
 
 uint64_t