Skip to contentSkip to conversation

app/testpmd: enable GTP header parse and Tx checksum offload

PATCH Superseded Ting Xu 4 participants 20 messages Oct 17, 2019 – Oct 28, 2019

lore
Share & tools
lore

Ting Xu

author
#0 lore raw

PATCH 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type. Currently, packet with outer IPv6 is not available.

---
 app/test-pmd/csumonly.c | 109 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 100 insertions(+), 9 deletions(-)
app/test-pmd/csumonly.c +100 -9
index e1cb7fb70..00f099482 100644
@@ -179,6 +179,84 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+	/* GTP destination port number */
+	uint16_t gtp_udpc_port = 2123;
+	uint16_t gtp_udpu_port = 2152;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(gtp_udpc_port) &&
+	    udp_hdr->src_port != _htons(gtp_udpc_port) &&
+	    udp_hdr->dst_port != _htons(gtp_udpu_port))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -478,15 +556,22 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +764,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -784,18 +870,23 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 		if (txp->parse_tunnel) {
 			if (info.l4_proto == IPPROTO_UDP) {
 				struct rte_udp_hdr *udp_hdr;
-
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
-				parse_vxlan_gpe(udp_hdr, &info);
+				parse_gtp(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
 				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
+					parse_vxlan_gpe(udp_hdr, &info);
+					if (info.is_tunnel) {
 						tx_ol_flags |=
+							PKT_TX_TUNNEL_VXLAN_GPE;
+					} else {
+						parse_vxlan(udp_hdr, &info,
+							    m->packet_type);
+						if (info.is_tunnel)
+							tx_ol_flags |=
 							PKT_TX_TUNNEL_VXLAN;
+					}
 				}
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
Signature · 1 line
2.17.1
author
#1 lore raw

PATCH v2 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
 app/test-pmd/csumonly.c | 109 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 100 insertions(+), 9 deletions(-)
app/test-pmd/csumonly.c +100 -9
index e1cb7fb70..d34116f0b 100644
@@ -179,6 +179,84 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+	/* GTP destination port number */
+	uint16_t gtpc_udp_port = 2123;
+	uint16_t gtpu_udp_port = 2152;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(gtpc_udp_port) &&
+	    udp_hdr->src_port != _htons(gtpc_udp_port) &&
+	    udp_hdr->dst_port != _htons(gtpu_udp_port))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -478,15 +556,22 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +764,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -784,18 +870,23 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 		if (txp->parse_tunnel) {
 			if (info.l4_proto == IPPROTO_UDP) {
 				struct rte_udp_hdr *udp_hdr;
-
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
-				parse_vxlan_gpe(udp_hdr, &info);
+				parse_gtp(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
 				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
+					parse_vxlan_gpe(udp_hdr, &info);
+					if (info.is_tunnel) {
 						tx_ol_flags |=
+							PKT_TX_TUNNEL_VXLAN_GPE;
+					} else {
+						parse_vxlan(udp_hdr, &info,
+							    m->packet_type);
+						if (info.is_tunnel)
+							tx_ol_flags |=
 							PKT_TX_TUNNEL_VXLAN;
+					}
 				}
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
Signature · 1 line
2.17.1
author
#2 lore raw

PATCH v3 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c | 115 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 104 insertions(+), 11 deletions(-)
app/test-pmd/csumonly.c +104 -11
index e1cb7fb70..b7ff7c742 100644
@@ -179,6 +179,84 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+	/* GTP destination port number */
+	uint16_t gtpc_udp_port = 2123;
+	uint16_t gtpu_udp_port = 2152;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(gtpc_udp_port) &&
+	    udp_hdr->src_port != _htons(gtpc_udp_port) &&
+	    udp_hdr->dst_port != _htons(gtpu_udp_port))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -473,20 +551,27 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 		else
 			ipv4_hdr->hdr_checksum = rte_ipv4_cksum(ipv4_hdr);
 	} else
-		ol_flags |= PKT_TX_OUTER_IPV6;
+		ol_flags |= (PKT_TX_OUTER_IPV6 | PKT_TX_OUTER_IP_CKSUM);
 
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +764,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -787,16 +873,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
+				parse_gtp(udp_hdr, &info);
+				if (info.is_tunnel) {
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
+					goto tunnel_update;
+				}
 				parse_vxlan_gpe(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
-				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
-						tx_ol_flags |=
-							PKT_TX_TUNNEL_VXLAN;
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN_GPE;
+					goto tunnel_update;
 				}
+				parse_vxlan(udp_hdr, &info,
+					    m->packet_type);
+				if (info.is_tunnel)
+					tx_ol_flags |=
+					PKT_TX_TUNNEL_VXLAN;
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
 
@@ -815,6 +907,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 			}
 		}
 
+tunnel_update:
 		/* update l3_hdr and outer_l3_hdr if a tunnel was parsed */
 		if (info.is_tunnel) {
 			outer_l3_hdr = l3_hdr;
Signature · 1 line
2.17.1
#3 lore raw
Quoted 8 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

<...>

Quoted 20 lines
app/test-pmd/csumonly.c +20 -0
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,

app/test-pmd/csumonly.c parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info) · line 211

Quoted 10 lines
app/test-pmd/csumonly.c +10 -0
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+	/* GTP destination port number */
+	uint16_t gtpc_udp_port = 2123;
+	uint16_t gtpu_udp_port = 2152;

What do you think about moving GTP related information into a gtp header file in net library?

author
#4 lore raw

Hi, Ferruh,

Thanks for your advice. I will move the header info into rte_ether.h. It could be better.

-----Original Message-----
From: Yigit, Ferruh
Sent: Saturday, October 19, 2019 2:50 AM
To: Xu, Ting <[email protected]>; [email protected]
Cc: Lu, Wenzhuo <[email protected]>; Wu, Jingjing <[email protected]>; Iremonger, Bernard <[email protected]>; Zhang, Qi Z <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v3] app/testpmd: enable GTP header parse and Tx checksum offload

Quoted 7 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

<...>

Quoted 19 lines
app/test-pmd/csumonly.c +19 -0
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+
+static void

app/test-pmd/csumonly.c parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info) · line 211

Quoted 10 lines
app/test-pmd/csumonly.c +10 -0
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info) {
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+	/* GTP destination port number */
+	uint16_t gtpc_udp_port = 2123;
+	uint16_t gtpu_udp_port = 2152;

What do you think about moving GTP related information into a gtp header file in net library?

author
#5 lore raw

PATCH v4 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

In reply to Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c    | 96 ++++++++++++++++++++++++++++++++++----
 lib/librte_net/rte_ether.h | 23 +++++++++
 2 files changed, 109 insertions(+), 10 deletions(-)
app/test-pmd/csumonly.c +86 -10
index e1cb7fb70..52adfffe1 100644
@@ -179,6 +179,67 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->src_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->dst_port != _htons(RTE_GTPU_UDP_PORT))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -478,15 +539,22 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +747,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -787,16 +856,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
+				parse_gtp(udp_hdr, &info);
+				if (info.is_tunnel) {
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
+					goto tunnel_update;
+				}
 				parse_vxlan_gpe(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
-				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
-						tx_ol_flags |=
-							PKT_TX_TUNNEL_VXLAN;
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN_GPE;
+					goto tunnel_update;
 				}
+				parse_vxlan(udp_hdr, &info,
+					    m->packet_type);
+				if (info.is_tunnel)
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN;
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
 
@@ -815,6 +890,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 			}
 		}
 
+tunnel_update:
 		/* update l3_hdr and outer_l3_hdr if a tunnel was parsed */
 		if (info.is_tunnel) {
 			outer_l3_hdr = l3_hdr;
lib/librte_net/rte_ether.h +23 -0
index aa6eff037..33ad347d8 100644
@@ -342,6 +342,29 @@ struct rte_vxlan_gpe_hdr {
 			      sizeof(struct rte_vxlan_gpe_hdr))
 /**< VXLAN-GPE tunnel header length. */
 
+/**
+ * Simplified GTP protocol header.
+ * Contains 8-bit flag, 8-bit message type,
+ * 16-bit message length, 32-bit TEID.
+ * No optional fields and next extension header.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+/* GTP destination port number */
+#define RTE_GTPC_UDP_PORT 2123
+#define RTE_GTPU_UDP_PORT 2152
+
 /**
  * Extract VLAN tag information into mbuf
  *
Signature · 1 line
2.17.1
#6 lore raw
Quoted 17 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c    | 96 ++++++++++++++++++++++++++++++++++----
 lib/librte_net/rte_ether.h | 23 +++++++++
 2 files changed, 109 insertions(+), 10 deletions(-)

<...>

Quoted 23 lines
lib/librte_net/rte_ether.h +16 -0
@@ -342,6 +342,29 @@ struct rte_vxlan_gpe_hdr {
 			      sizeof(struct rte_vxlan_gpe_hdr))
 /**< VXLAN-GPE tunnel header length. */
 
+/**
+ * Simplified GTP protocol header.
+ * Contains 8-bit flag, 8-bit message type,
+ * 16-bit message length, 32-bit TEID.
+ * No optional fields and next extension header.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))

lib/librte_net/rte_ether.h struct rte_vxlan_gpe_hdr { · line 370

Quoted 10 lines
lib/librte_net/rte_ether.h +7 -0
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+/* GTP destination port number */
+#define RTE_GTPC_UDP_PORT 2123
+#define RTE_GTPU_UDP_PORT 2152
+
 /**
  * Extract VLAN tag information into mbuf
  *

lgtm, @Oliver, any comment/objection on GTP part in rte_ether.h?

#7 lore raw
Quoted 48 lines · Ferruh Yigit
Quoted 17 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c    | 96 ++++++++++++++++++++++++++++++++++----
 lib/librte_net/rte_ether.h | 23 +++++++++
 2 files changed, 109 insertions(+), 10 deletions(-)

<...>

Quoted 27 lines
lib/librte_net/rte_ether.h +21 -0
@@ -342,6 +342,29 @@ struct rte_vxlan_gpe_hdr {
 			      sizeof(struct rte_vxlan_gpe_hdr))
 /**< VXLAN-GPE tunnel header length. */
 
+/**
+ * Simplified GTP protocol header.
+ * Contains 8-bit flag, 8-bit message type,
+ * 16-bit message length, 32-bit TEID.
+ * No optional fields and next extension header.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+/* GTP destination port number */
+#define RTE_GTPC_UDP_PORT 2123
Quoted 9 lines

lib/librte_net/rte_ether.h struct rte_vxlan_gpe_hdr { · line 370

Quoted 6 lines
lib/librte_net/rte_ether.h +2 -0
+#define RTE_GTPU_UDP_PORT 2152
+
 /**
  * Extract VLAN tag information into mbuf
  *

lgtm, @Oliver, any comment/objection on GTP part in rte_ether.h?

What about moving the defines to its own header, like rte_gtp? Is these defines part of the ether?

#8 lore raw
Quoted 59 lines · Ferruh Yigit
Quoted 48 lines · Ferruh Yigit
Quoted 17 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c    | 96 ++++++++++++++++++++++++++++++++++----
 lib/librte_net/rte_ether.h | 23 +++++++++
 2 files changed, 109 insertions(+), 10 deletions(-)

<...>

Quoted 27 lines
lib/librte_net/rte_ether.h +21 -0
@@ -342,6 +342,29 @@ struct rte_vxlan_gpe_hdr {
 			      sizeof(struct rte_vxlan_gpe_hdr))
 /**< VXLAN-GPE tunnel header length. */
 
+/**
+ * Simplified GTP protocol header.
+ * Contains 8-bit flag, 8-bit message type,
+ * 16-bit message length, 32-bit TEID.
+ * No optional fields and next extension header.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+/* GTP destination port number */
+#define RTE_GTPC_UDP_PORT 2123
Quoted 9 lines

lib/librte_net/rte_ether.h struct rte_vxlan_gpe_hdr { · line 370

Quoted 6 lines
lib/librte_net/rte_ether.h +2 -0
+#define RTE_GTPU_UDP_PORT 2152
+
 /**
  * Extract VLAN tag information into mbuf
  *

lgtm, @Oliver, any comment/objection on GTP part in rte_ether.h?

Quoted 2 lines

What about moving the defines to its own header, like rte_gtp? Is these defines part of the ether?

+1

I also think it deserves its own file.

author
#9 lore raw

Hi, Ferruh, Olivier,

Thanks for your advice. I think I misunderstood the comments in the last commit. This time I move the GTP header definition in the new file rte_gtp.h. Hope it would be better.

Thanks.

-----Original Message-----
From: Olivier Matz [mailto:[email protected]]
Sent: Tuesday, October 22, 2019 12:51 AM
To: Yigit, Ferruh <[email protected]>
Cc: Xu, Ting <[email protected]>; [email protected]; Lu, Wenzhuo <[email protected]>; Wu, Jingjing <[email protected]>; Iremonger, Bernard <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v4] app/testpmd: enable GTP header parse and Tx checksum offload

Quoted 59 lines · Ferruh Yigit
Quoted 48 lines · Ferruh Yigit
Quoted 17 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. GTP header structure (without optional fields and extension header) and parser function are added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c    | 96 ++++++++++++++++++++++++++++++++++----
 lib/librte_net/rte_ether.h | 23 +++++++++
 2 files changed, 109 insertions(+), 10 deletions(-)

<...>

Quoted 27 lines
lib/librte_net/rte_ether.h +0 -0
@@ -342,6 +342,29 @@ struct rte_vxlan_gpe_hdr {
 			      sizeof(struct rte_vxlan_gpe_hdr))  /**< VXLAN-GPE tunnel 

header length. */

lib/librte_net/rte_ether.h +21 -0
+/**
+ * Simplified GTP protocol header.
+ * Contains 8-bit flag, 8-bit message type,
+ * 16-bit message length, 32-bit TEID.
+ * No optional fields and next extension header.
+ */
+struct rte_gtp_hdr {
+	uint8_t gtp_hdr_info;
+	uint8_t msg_type;
+	uint16_t msg_len;
+	uint32_t teid;
+} __attribute__((__packed__));
+
+/* GTP header length */
+#define RTE_ETHER_GTP_HLEN \
+	(sizeof(struct rte_udp_hdr) + sizeof(struct rte_gtp_hdr))
+/* GTP next protocal type */
+#define RTE_GTP_TYPE_IPV4 0x40
+#define RTE_GTP_TYPE_IPV6 0x60
+/* GTP destination port number */
+#define RTE_GTPC_UDP_PORT 2123
Quoted 9 lines

lib/librte_net/rte_ether.h struct rte_vxlan_gpe_hdr { · line 370

Quoted 6 lines
lib/librte_net/rte_ether.h +2 -0
+#define RTE_GTPU_UDP_PORT 2152
+
 /**
  * Extract VLAN tag information into mbuf
  *

lgtm, @Oliver, any comment/objection on GTP part in rte_ether.h?

Quoted 2 lines

What about moving the defines to its own header, like rte_gtp? Is these defines part of the ether?

+1

I also think it deserves its own file.

author
#10 lore raw

PATCH v5 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

In reply to Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v5: Create rte_gtp.h and move GTP header defination to it.
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c  | 97 +++++++++++++++++++++++++++++++++++-----
 lib/librte_net/Makefile  |  2 +-
 lib/librte_net/rte_gtp.h | 52 +++++++++++++++++++++
 3 files changed, 140 insertions(+), 11 deletions(-)
 create mode 100644 lib/librte_net/rte_gtp.h
app/test-pmd/csumonly.c +87 -10
index e1cb7fb70..c3fd5e17d 100644
@@ -36,6 +36,7 @@
 #include <rte_tcp.h>
 #include <rte_udp.h>
 #include <rte_sctp.h>
+#include <rte_gtp.h>
 #include <rte_prefetch.h>
 #include <rte_string_fns.h>
 #include <rte_flow.h>
@@ -179,6 +180,67 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->src_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->dst_port != _htons(RTE_GTPU_UDP_PORT))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -478,15 +540,22 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +748,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -787,16 +857,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
+				parse_gtp(udp_hdr, &info);
+				if (info.is_tunnel) {
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
+					goto tunnel_update;
+				}
 				parse_vxlan_gpe(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
-				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
-						tx_ol_flags |=
-							PKT_TX_TUNNEL_VXLAN;
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN_GPE;
+					goto tunnel_update;
 				}
+				parse_vxlan(udp_hdr, &info,
+					    m->packet_type);
+				if (info.is_tunnel)
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN;
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
 
@@ -815,6 +891,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 			}
 		}
 
+tunnel_update:
 		/* update l3_hdr and outer_l3_hdr if a tunnel was parsed */
 		if (info.is_tunnel) {
 			outer_l3_hdr = l3_hdr;
lib/librte_net/Makefile +1 -1
index 1244c9fd5..4ad02aee0 100644
@@ -20,7 +20,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_NET) += rte_arp.c
 # install includes
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include := rte_ip.h rte_tcp.h rte_udp.h rte_esp.h
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_sctp.h rte_icmp.h rte_arp.h
-SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_ether.h rte_gre.h rte_net.h
+SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_ether.h rte_gre.h rte_gtp.h rte_net.h
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_net_crc.h rte_mpls.h
 
 include $(RTE_SDK)/mk/rte.lib.mk
lib/librte_net/rte_gtp.h new file +52 -0

52 lines not on this page · raw message

Signature · 1 line
2.17.1
#11 lore raw
Quoted 15 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v5: Create rte_gtp.h and move GTP header defination to it.
v4: Move GTP header defination to rte_ether.h
v3: correct coding style issue.
v2: modify commit log
depend on patch: lib/mbuf: add GTP tunnel type flag.

Quoted 4 lines
---
 app/test-pmd/csumonly.c  | 97 +++++++++++++++++++++++++++++++++++-----
 lib/librte_net/Makefile  |  2 +-
 lib/librte_net/rte_gtp.h | 52 +++++++++++++++++++++

Thanks Ting,

Can you also please this new header to 'doc/api/doxy-api-index.md' so that it can be part of API documentation, and can you please be sure the header file doxygen documentation is complete?

Thanks,
ferruh

Quoted 2 lines
 3 files changed, 140 insertions(+), 11 deletions(-)
 create mode 100644 lib/librte_net/rte_gtp.h

<...>

author
#12 lore raw

PATCH v6 1/1 app/testpmd: enable GTP header parse and Tx checksum offload

In reply to Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c   | 97 +++++++++++++++++++++++++++++++++++----
 doc/api/doxy-api-index.md |  1 +
 lib/librte_net/Makefile   |  2 +-
 lib/librte_net/rte_gtp.h  | 52 +++++++++++++++++++++
 4 files changed, 141 insertions(+), 11 deletions(-)
 create mode 100644 lib/librte_net/rte_gtp.h
app/test-pmd/csumonly.c +87 -10
index e1cb7fb70..c3fd5e17d 100644
@@ -36,6 +36,7 @@
 #include <rte_tcp.h>
 #include <rte_udp.h>
 #include <rte_sctp.h>
+#include <rte_gtp.h>
 #include <rte_prefetch.h>
 #include <rte_string_fns.h>
 #include <rte_flow.h>
@@ -179,6 +180,67 @@ parse_ethernet(struct rte_ether_hdr *eth_hdr, struct testpmd_offload_info *info)
 	}
 }
 
+/*
+ * Parse a GTP protocol header.
+ * No optional fields and next extension header type.
+ */
+static void
+parse_gtp(struct rte_udp_hdr *udp_hdr,
+	  struct testpmd_offload_info *info)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_ipv6_hdr *ipv6_hdr;
+	struct rte_gtp_hdr *gtp_hdr;
+	uint8_t gtp_len = sizeof(*gtp_hdr);
+	uint8_t ip_ver;
+
+	/* Check udp destination port. */
+	if (udp_hdr->dst_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->src_port != _htons(RTE_GTPC_UDP_PORT) &&
+	    udp_hdr->dst_port != _htons(RTE_GTPU_UDP_PORT))
+		return;
+
+	info->is_tunnel = 1;
+	info->outer_ethertype = info->ethertype;
+	info->outer_l2_len = info->l2_len;
+	info->outer_l3_len = info->l3_len;
+	info->outer_l4_proto = info->l4_proto;
+	info->l2_len = 0;
+
+	gtp_hdr = (struct rte_gtp_hdr *)((char *)udp_hdr +
+		  sizeof(struct rte_udp_hdr));
+
+	/*
+	 * Check message type. If message type is 0xff, it is
+	 * a GTP data packet. If not, it is a GTP control packet
+	 */
+	if (gtp_hdr->msg_type == 0xff) {
+		ip_ver = *(uint8_t *)((char *)udp_hdr +
+			 sizeof(struct rte_udp_hdr) +
+			 sizeof(struct rte_gtp_hdr));
+		ip_ver = (ip_ver) & 0xf0;
+
+		if (ip_ver == RTE_GTP_TYPE_IPV4) {
+			ipv4_hdr = (struct rte_ipv4_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV4);
+			parse_ipv4(ipv4_hdr, info);
+		} else if (ip_ver == RTE_GTP_TYPE_IPV6) {
+			ipv6_hdr = (struct rte_ipv6_hdr *)((char *)gtp_hdr +
+				   gtp_len);
+			info->ethertype = _htons(RTE_ETHER_TYPE_IPV6);
+			parse_ipv6(ipv6_hdr, info);
+		}
+	} else {
+		info->ethertype = 0;
+		info->l4_len = 0;
+		info->l3_len = 0;
+		info->l4_proto = 0;
+	}
+
+	info->l2_len += RTE_ETHER_GTP_HLEN;
+}
+
 /* Parse a vxlan header */
 static void
 parse_vxlan(struct rte_udp_hdr *udp_hdr,
@@ -478,15 +540,22 @@ process_outer_cksums(void *outer_l3_hdr, struct testpmd_offload_info *info,
 	if (info->outer_l4_proto != IPPROTO_UDP)
 		return ol_flags;
 
+	udp_hdr = (struct rte_udp_hdr *)
+		((char *)outer_l3_hdr + info->outer_l3_len);
+
 	/* Skip SW outer UDP checksum generation if HW supports it */
 	if (tx_offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM) {
+		if (info->outer_ethertype == _htons(RTE_ETHER_TYPE_IPV4))
+			udp_hdr->dgram_cksum
+				= rte_ipv4_phdr_cksum(ipv4_hdr, ol_flags);
+		else
+			udp_hdr->dgram_cksum
+				= rte_ipv6_phdr_cksum(ipv6_hdr, ol_flags);
+
 		ol_flags |= PKT_TX_OUTER_UDP_CKSUM;
 		return ol_flags;
 	}
 
-	udp_hdr = (struct rte_udp_hdr *)
-		((char *)outer_l3_hdr + info->outer_l3_len);
-
 	/* outer UDP checksum is done in software. In the other side, for
 	 * UDP tunneling, like VXLAN or Geneve, outer UDP checksum can be
 	 * set to zero.
@@ -679,6 +748,7 @@ pkt_copy_split(const struct rte_mbuf *pkt)
  *           UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / outer UDP / VXLAN-GPE / IP|IP6 /
  *           UDP|TCP|SCTP
+ *   Ether / (vlan) / outer IP / outer UDP / GTP / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / Ether / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / GRE / IP|IP6 / UDP|TCP|SCTP
  *   Ether / (vlan) / outer IP|IP6 / IP|IP6 / UDP|TCP|SCTP
@@ -787,16 +857,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 				udp_hdr = (struct rte_udp_hdr *)
 					((char *)l3_hdr + info.l3_len);
+				parse_gtp(udp_hdr, &info);
+				if (info.is_tunnel) {
+					tx_ol_flags |= PKT_TX_TUNNEL_GTP;
+					goto tunnel_update;
+				}
 				parse_vxlan_gpe(udp_hdr, &info);
 				if (info.is_tunnel) {
-					tx_ol_flags |= PKT_TX_TUNNEL_VXLAN_GPE;
-				} else {
-					parse_vxlan(udp_hdr, &info,
-						    m->packet_type);
-					if (info.is_tunnel)
-						tx_ol_flags |=
-							PKT_TX_TUNNEL_VXLAN;
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN_GPE;
+					goto tunnel_update;
 				}
+				parse_vxlan(udp_hdr, &info,
+					    m->packet_type);
+				if (info.is_tunnel)
+					tx_ol_flags |=
+						PKT_TX_TUNNEL_VXLAN;
 			} else if (info.l4_proto == IPPROTO_GRE) {
 				struct simple_gre_hdr *gre_hdr;
 
@@ -815,6 +891,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 			}
 		}
 
+tunnel_update:
 		/* update l3_hdr and outer_l3_hdr if a tunnel was parsed */
 		if (info.is_tunnel) {
 			outer_l3_hdr = l3_hdr;
doc/api/doxy-api-index.md +1 -0
index 6c2d888ee..8c21d426f 100644
@@ -97,6 +97,7 @@ The public API headers are grouped by topics:
   [SCTP]               (@ref rte_sctp.h),
   [TCP]                (@ref rte_tcp.h),
   [UDP]                (@ref rte_udp.h),
+  [GTP]                (@ref rte_gtp.h),
   [GRO]                (@ref rte_gro.h),
   [GSO]                (@ref rte_gso.h),
   [frag/reass]         (@ref rte_ip_frag.h),
lib/librte_net/Makefile +1 -1
index 1244c9fd5..4ad02aee0 100644
@@ -20,7 +20,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_NET) += rte_arp.c
 # install includes
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include := rte_ip.h rte_tcp.h rte_udp.h rte_esp.h
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_sctp.h rte_icmp.h rte_arp.h
-SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_ether.h rte_gre.h rte_net.h
+SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_ether.h rte_gre.h rte_gtp.h rte_net.h
 SYMLINK-$(CONFIG_RTE_LIBRTE_NET)-include += rte_net_crc.h rte_mpls.h
 
 include $(RTE_SDK)/mk/rte.lib.mk
lib/librte_net/rte_gtp.h new file +52 -0

52 lines not on this page · raw message

Signature · 1 line
2.17.1
Reviewed-by on v6 1/1
#13 lore raw
Quoted 16 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 1 line

depend on patch: lib/mbuf: add GTP tunnel type flag.

Will wait mbuf patch to be applied to get the patch.

Applied
#14 lore raw
Quoted 17 lines · Ferruh Yigit
Quoted 16 lines · Ting Xu

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 6 lines
Quoted 1 line

depend on patch: lib/mbuf: add GTP tunnel type flag.

Will wait mbuf patch to be applied to get the patch.

Applied to dpdk-next-net/master, thanks.

#15 lore raw

23/10/2019 19:23, Ferruh Yigit:

Quoted 18 lines · Ferruh Yigit
Quoted 17 lines · Ting Xu
Quoted 16 lines

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 8 lines
Quoted 6 lines
Quoted 1 line

depend on patch: lib/mbuf: add GTP tunnel type flag.

Will wait mbuf patch to be applied to get the patch.

Applied to dpdk-next-net/master, thanks.

Sorry, dropped from pull in master.
An update of meson.build is missing and it makes me feel something else may be missing.

#16 lore raw

26/10/2019 00:43, Thomas Monjalon:

Quoted 23 lines

23/10/2019 19:23, Ferruh Yigit:

Quoted 22 lines · Ferruh Yigit
Quoted 21 lines · Ting Xu
Quoted 16 lines

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 1 line

depend on patch: lib/mbuf: add GTP tunnel type flag.

Quoted 8 lines
Quoted 4 lines
Quoted 2 lines

Will wait mbuf patch to be applied to get the patch.

Applied to dpdk-next-net/master, thanks.

Sorry, dropped from pull in master.
An update of meson.build is missing and it makes me feel something else may be missing.

Changed my mind: I pull it in the master branch with few fixes.

#17 lore raw
In reply to Ting Xu

22/10/2019 18:26, Ting Xu:

Quoted 16 lines

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 5 lines

depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c   | 97 +++++++++++++++++++++++++++++++++++----
 doc/api/doxy-api-index.md |  1 +
 lib/librte_net/Makefile   |  2 +-

You missed meson.build in addition of Makefile.

Quoted 3 lines
 lib/librte_net/rte_gtp.h  | 52 +++++++++++++++++++++
 4 files changed, 141 insertions(+), 11 deletions(-)
 create mode 100644 lib/librte_net/rte_gtp.h

Does it deserve 2 separate patches? GTP header + testpmd use

[...]

Quoted 2 lines
lib/librte_net/rte_gtp.h new file +0 -0

[...]

lib/librte_net/rte_gtp.h line 52

Quoted 3 lines
lib/librte_net/rte_gtp.h new file +3 -0
+
+#endif /* RTE_GTP_H_ */
+

Please remove this blank line at EOF. Such things are cleaned up sometimes:

	http://git.dpdk.org/dpdk/commit/?id=6f3f0acd95
author
#18 lore raw

Hi, Thomas,

Sorry for my mistake about missing meson.build. I have fixed it as well as others based on your comments. However, I am not quite understand your last reply. Do I still need to send a new patch now or not?

Thanks for your patient help!

Best Regards,
Ting Xu

-----Original Message-----
From: Thomas Monjalon <[email protected]>
Sent: Saturday, October 26, 2019 6:49 AM
To: Xu, Ting <[email protected]>
Cc: [email protected]; Lu, Wenzhuo <[email protected]>; Wu, Jingjing <[email protected]>; Iremonger, Bernard <[email protected]>; [email protected]; Yigit, Ferruh <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v6] app/testpmd: enable GTP header parse and Tx checksum offload

22/10/2019 18:26, Ting Xu:

Quoted 15 lines

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 5 lines

depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c   | 97 +++++++++++++++++++++++++++++++++++----
 doc/api/doxy-api-index.md |  1 +
 lib/librte_net/Makefile   |  2 +-

You missed meson.build in addition of Makefile.

Quoted 3 lines
 lib/librte_net/rte_gtp.h  | 52 +++++++++++++++++++++
 4 files changed, 141 insertions(+), 11 deletions(-)  create mode 

100644 lib/librte_net/rte_gtp.h

Does it deserve 2 separate patches? GTP header + testpmd use

[...]

Quoted 2 lines
lib/librte_net/rte_gtp.h new file +0 -0

[...]

lib/librte_net/rte_gtp.h line 52

Quoted 3 lines
lib/librte_net/rte_gtp.h new file +3 -0
+
+#endif /* RTE_GTP_H_ */
+

Please remove this blank line at EOF. Such things are cleaned up sometimes:

	http://git.dpdk.org/dpdk/commit/?id=6f3f0acd95
#19 lore raw

28/10/2019 02:35, Xu, Ting:

Quoted 4 lines

Hi, Thomas,

Sorry for my mistake about missing meson.build. I have fixed it as well as others based on your comments. However, I am not quite understand your last reply. Do I still need to send a new patch now or not?

No, this is already merged: http://git.dpdk.org/dpdk/commit/?id=d8e5e69f3a

Quoted 52 lines

Thanks for your patient help!

Best Regards,
Ting Xu

-----Original Message-----
From: Thomas Monjalon <[email protected]>
Sent: Saturday, October 26, 2019 6:49 AM
To: Xu, Ting <[email protected]>
Cc: [email protected]; Lu, Wenzhuo <[email protected]>; Wu, Jingjing <[email protected]>; Iremonger, Bernard <[email protected]>; [email protected]; Yigit, Ferruh <[email protected]>
Subject: Re: [dpdk-dev] [PATCH v6] app/testpmd: enable GTP header parse and Tx checksum offload

22/10/2019 18:26, Ting Xu:

Quoted 15 lines

This patch enables testpmd to forward GTP packet in csum fwd mode. A GTP header structure (without optional fields and extension header) is defined in new rte_gtp.h. A parser function in testpmd is added. GTPU and GTPC packets are both supported, with respective UDP destination port and GTP message type.

---
v6: complete doxygen documentation.
v5: create rte_gtp.h and move GTP header definition to it.
v4: move GTP header definition to rte_ether.h
v3: correct coding style issue.
v2: modify commit log

Quoted 5 lines

depend on patch: lib/mbuf: add GTP tunnel type flag.

---
 app/test-pmd/csumonly.c   | 97 +++++++++++++++++++++++++++++++++++----
 doc/api/doxy-api-index.md |  1 +
 lib/librte_net/Makefile   |  2 +-

You missed meson.build in addition of Makefile.

Quoted 3 lines
 lib/librte_net/rte_gtp.h  | 52 +++++++++++++++++++++
 4 files changed, 141 insertions(+), 11 deletions(-)  create mode 

100644 lib/librte_net/rte_gtp.h

Does it deserve 2 separate patches? GTP header + testpmd use

[...]

Quoted 2 lines
lib/librte_net/rte_gtp.h new file +0 -0

[...]

lib/librte_net/rte_gtp.h line 52

Quoted 3 lines
lib/librte_net/rte_gtp.h new file +3 -0
+
+#endif /* RTE_GTP_H_ */
+

Please remove this blank line at EOF. Such things are cleaned up sometimes:

	http://git.dpdk.org/dpdk/commit/?id=6f3f0acd95