1 files changed, 134 insertions, 206 deletions

diff --git a/platform/linux-dpdk/odp_packet.c b/platform/linux-dpdk/odp_packet.c
index 06f5a19cb..0d05e23f2 100644
--- a/platform/linux-dpdk/odp_packet.c
+++ b/platform/linux-dpdk/odp_packet.c
@@ -81,24 +81,6 @@ static inline odp_packet_hdr_t *buf_to_packet_hdr(odp_buffer_t buf)
 	return (odp_packet_hdr_t *)buf_hdl_to_hdr(buf);
 }
 
-static inline void packet_parse_disable(odp_packet_hdr_t *pkt_hdr)
-{
-	pkt_hdr->p.input_flags.parsed_l2  = 1;
-	pkt_hdr->p.parsed_layers = LAYER_ALL;
-}
-
-void packet_parse_reset(odp_packet_hdr_t *pkt_hdr)
-{
-	/* Reset parser metadata before new parse */
-	pkt_hdr->p.parsed_layers    = LAYER_NONE;
-	pkt_hdr->p.error_flags.all  = 0;
-	pkt_hdr->p.input_flags.all  = 0;
-	pkt_hdr->p.output_flags.all = 0;
-	pkt_hdr->p.l2_offset        = 0;
-	pkt_hdr->p.l3_offset        = ODP_PACKET_OFFSET_INVALID;
-	pkt_hdr->p.l4_offset        = ODP_PACKET_OFFSET_INVALID;
-}
-
 static odp_packet_t packet_alloc(pool_entry_t* pool, uint32_t len)
 {
 	odp_packet_t pkt;
@@ -198,7 +180,6 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len)
 		return -1;
 	}
 
-	pkt_hdr->p.parsed_layers    = LAYER_NONE;
 	pkt_hdr->p.input_flags.all  = 0;
 	pkt_hdr->p.output_flags.all = 0;
 	pkt_hdr->p.error_flags.all  = 0;
@@ -211,9 +192,6 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len)
 
 	pkt_hdr->input = ODP_PKTIO_INVALID;
 
-	/* Disable lazy parsing on user allocated packets */
-	packet_parse_disable(pkt_hdr);
-
 	mb->port = 0xff;
 	mb->pkt_len = len;
 	mb->data_off = RTE_PKTMBUF_HEADROOM;
@@ -627,8 +605,6 @@ void *odp_packet_l3_ptr(odp_packet_t pkt, uint32_t *len)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L3)
-		packet_parse_layer(pkt_hdr, LAYER_L3);
 	return packet_offset_to_ptr(pkt, len, pkt_hdr->p.l3_offset);
 }
 
@@ -636,8 +612,6 @@ uint32_t odp_packet_l3_offset(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L3)
-		packet_parse_layer(pkt_hdr, LAYER_L3);
 	return pkt_hdr->p.l3_offset;
 }
 
@@ -648,8 +622,6 @@ int odp_packet_l3_offset_set(odp_packet_t pkt, uint32_t offset)
 	if (odp_unlikely(offset >= (odp_packet_len(pkt) - 1)))
 		return -1;
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L3)
-		packet_parse_layer(pkt_hdr, LAYER_L3);
 	pkt_hdr->p.l3_offset = offset;
 	return 0;
 }
@@ -658,8 +630,6 @@ void *odp_packet_l4_ptr(odp_packet_t pkt, uint32_t *len)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L4)
-		packet_parse_layer(pkt_hdr, LAYER_L4);
 	return packet_offset_to_ptr(pkt, len, pkt_hdr->p.l4_offset);
 }
 
@@ -667,8 +637,6 @@ uint32_t odp_packet_l4_offset(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L4)
-		packet_parse_layer(pkt_hdr, LAYER_L4);
 	return pkt_hdr->p.l4_offset;
 }
 
@@ -679,8 +647,6 @@ int odp_packet_l4_offset_set(odp_packet_t pkt, uint32_t offset)
 	if (odp_unlikely(offset >= (odp_packet_len(pkt) - 1)))
 		return -1;
 
-	if (pkt_hdr->p.parsed_layers < LAYER_L4)
-		packet_parse_layer(pkt_hdr, LAYER_L4);
 	pkt_hdr->p.l4_offset = offset;
 	return 0;
 }
@@ -1152,12 +1118,11 @@ static inline uint8_t parse_ipv4(packet_parser_t *prs, const uint8_t **parseptr,
 	uint8_t ihl = _ODP_IPV4HDR_IHL(ipv4->ver_ihl);
 	uint16_t frag_offset;
 	uint32_t dstaddr = odp_be_to_cpu_32(ipv4->dst_addr);
-
-	prs->l3_len = odp_be_to_cpu_16(ipv4->tot_len);
+	uint32_t l3_len = odp_be_to_cpu_16(ipv4->tot_len);
 
 	if (odp_unlikely(ihl < _ODP_IPV4HDR_IHL_MIN) ||
 	    odp_unlikely(ver != 4) ||
-	    (prs->l3_len > frame_len - *offset)) {
+	    (l3_len > frame_len - *offset)) {
 		prs->error_flags.ip_err = 1;
 		return 0;
 	}
@@ -1194,13 +1159,12 @@ static inline uint8_t parse_ipv6(packet_parser_t *prs, const uint8_t **parseptr,
 	const _odp_ipv6hdr_t *ipv6 = (const _odp_ipv6hdr_t *)*parseptr;
 	const _odp_ipv6hdr_ext_t *ipv6ext;
 	uint32_t dstaddr0 = odp_be_to_cpu_32(ipv6->dst_addr.u8[0]);
-
-	prs->l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
-				_ODP_IPV6HDR_LEN;
+	uint32_t l3_len = odp_be_to_cpu_16(ipv6->payload_len) +
+			_ODP_IPV6HDR_LEN;
 
 	/* Basic sanity checks on IPv6 header */
 	if ((odp_be_to_cpu_32(ipv6->ver_tc_flow) >> 28) != 6 ||
-	    prs->l3_len > frame_len - *offset) {
+	    l3_len > frame_len - *offset) {
 		prs->error_flags.ip_err = 1;
 		return 0;
 	}
@@ -1261,9 +1225,6 @@ static inline void parse_tcp(packet_parser_t *prs,
 	else if ((uint32_t)tcp->hl * 4 > sizeof(_odp_tcphdr_t))
 		prs->input_flags.tcpopt = 1;
 
-	prs->l4_len = prs->l3_len +
-		prs->l3_offset - prs->l4_offset;
-
 	if (offset)
 		*offset   += (uint32_t)tcp->hl * 4;
 	*parseptr += (uint32_t)tcp->hl * 4;
@@ -1278,13 +1239,8 @@ static inline void parse_udp(packet_parser_t *prs,
 	const _odp_udphdr_t *udp = (const _odp_udphdr_t *)*parseptr;
 	uint32_t udplen = odp_be_to_cpu_16(udp->length);
 
-	if (udplen < sizeof(_odp_udphdr_t) ||
-	    udplen > (prs->l3_len +
-		      prs->l4_offset - prs->l3_offset)) {
+	if (odp_unlikely(udplen < sizeof(_odp_udphdr_t)))
 		prs->error_flags.udp_err = 1;
-	}
-
-	prs->l4_len = udplen;
 
 	if (offset)
 		*offset   += sizeof(_odp_udphdr_t);
@@ -1298,200 +1254,172 @@ static inline void parse_udp(packet_parser_t *prs,
  * available from the ptr.
  */
 int packet_parse_common(packet_parser_t *prs, const uint8_t *ptr,
-			uint32_t frame_len, uint32_t seg_len, layer_t layer)
+			uint32_t frame_len, uint32_t seg_len,
+			odp_pktio_parser_layer_t layer)
 {
 	uint32_t offset;
+	uint16_t ethtype;
 	const uint8_t *parseptr;
+	uint8_t  ip_proto;
+	const _odp_ethhdr_t *eth;
+	uint16_t macaddr0, macaddr2, macaddr4;
+	const _odp_vlanhdr_t *vlan;
 
-	switch (prs->parsed_layers) {
-	case LAYER_NONE:
-	/* Fall through */
-
-	case LAYER_L2:
-	{
-		const _odp_ethhdr_t *eth;
-		uint16_t macaddr0, macaddr2, macaddr4;
-		const _odp_vlanhdr_t *vlan;
-
-		offset = sizeof(_odp_ethhdr_t);
-		if (packet_parse_l2_not_done(prs))
-			packet_parse_l2(prs, frame_len);
-
-		eth = (const _odp_ethhdr_t *)ptr;
-
-		/* Handle Ethernet broadcast/multicast addresses */
-		macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)
-					    (const void *)eth));
-		prs->input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
-
-		if (macaddr0 == 0xffff) {
-			macaddr2 =
-				odp_be_to_cpu_16(*((const uint16_t *)
-						   (const void *)eth + 1));
-			macaddr4 =
-				odp_be_to_cpu_16(*((const uint16_t *)
-						   (const void *)eth + 2));
-			prs->input_flags.eth_bcast =
-				(macaddr2 == 0xffff) && (macaddr4 == 0xffff);
-		} else {
-			prs->input_flags.eth_bcast = 0;
-		}
-
-		/* Get Ethertype */
-		prs->ethtype = odp_be_to_cpu_16(eth->type);
-		parseptr = (const uint8_t *)(eth + 1);
+	if (layer == ODP_PKTIO_PARSER_LAYER_NONE)
+		return 0;
 
-		/* Check for SNAP vs. DIX */
-		if (prs->ethtype < _ODP_ETH_LEN_MAX) {
-			prs->input_flags.snap = 1;
-			if (prs->ethtype > frame_len - offset) {
-				prs->error_flags.snap_len = 1;
-				goto parse_exit;
-			}
-			prs->ethtype = odp_be_to_cpu_16(*((const uint16_t *)
-							(uintptr_t)
-							(parseptr + 6)));
-			offset   += 8;
-			parseptr += 8;
-		}
+	/* We only support Ethernet for now */
+	prs->input_flags.eth = 1;
+	/* Assume valid L2 header, no CRC/FCS check in SW */
+	prs->input_flags.l2 = 1;
+	/* Detect jumbo frames */
+	if (frame_len > _ODP_ETH_LEN_MAX)
+		prs->input_flags.jumbo = 1;
+
+	offset = sizeof(_odp_ethhdr_t);
+	eth = (const _odp_ethhdr_t *)ptr;
+
+	/* Handle Ethernet broadcast/multicast addresses */
+	macaddr0 = odp_be_to_cpu_16(*((const uint16_t *)(const void *)eth));
+	prs->input_flags.eth_mcast = (macaddr0 & 0x0100) == 0x0100;
+
+	if (macaddr0 == 0xffff) {
+		macaddr2 =
+			odp_be_to_cpu_16(*((const uint16_t *)
+					   (const void *)eth + 1));
+		macaddr4 =
+			odp_be_to_cpu_16(*((const uint16_t *)
+					   (const void *)eth + 2));
+		prs->input_flags.eth_bcast =
+			(macaddr2 == 0xffff) && (macaddr4 == 0xffff);
+	} else {
+		prs->input_flags.eth_bcast = 0;
+	}
 
-		/* Parse the VLAN header(s), if present */
-		if (prs->ethtype == _ODP_ETHTYPE_VLAN_OUTER) {
-			prs->input_flags.vlan_qinq = 1;
-			prs->input_flags.vlan = 1;
+	/* Get Ethertype */
+	ethtype = odp_be_to_cpu_16(eth->type);
+	parseptr = (const uint8_t *)(eth + 1);
 
-			vlan = (const _odp_vlanhdr_t *)parseptr;
-			prs->ethtype = odp_be_to_cpu_16(vlan->type);
-			offset += sizeof(_odp_vlanhdr_t);
-			parseptr += sizeof(_odp_vlanhdr_t);
+	/* Check for SNAP vs. DIX */
+	if (ethtype < _ODP_ETH_LEN_MAX) {
+		prs->input_flags.snap = 1;
+		if (ethtype > frame_len - offset) {
+			prs->error_flags.snap_len = 1;
+			goto parse_exit;
 		}
+		ethtype = odp_be_to_cpu_16(*((const uint16_t *)(uintptr_t)
+					     (parseptr + 6)));
+		offset   += 8;
+		parseptr += 8;
+	}
 
-		if (prs->ethtype == _ODP_ETHTYPE_VLAN) {
-			prs->input_flags.vlan = 1;
-			vlan = (const _odp_vlanhdr_t *)parseptr;
-			prs->ethtype = odp_be_to_cpu_16(vlan->type);
-			offset += sizeof(_odp_vlanhdr_t);
-			parseptr += sizeof(_odp_vlanhdr_t);
-		}
+	/* Parse the VLAN header(s), if present */
+	if (ethtype == _ODP_ETHTYPE_VLAN_OUTER) {
+		prs->input_flags.vlan_qinq = 1;
+		prs->input_flags.vlan = 1;
 
-		prs->l3_offset = offset;
-		prs->parsed_layers = LAYER_L2;
-		if (layer == LAYER_L2)
-			return prs->error_flags.all != 0;
+		vlan = (const _odp_vlanhdr_t *)parseptr;
+		ethtype = odp_be_to_cpu_16(vlan->type);
+		offset += sizeof(_odp_vlanhdr_t);
+		parseptr += sizeof(_odp_vlanhdr_t);
 	}
-	/* Fall through */
 
-	case LAYER_L3:
-	{
-		offset = prs->l3_offset;
-		parseptr = (const uint8_t *)(ptr + offset);
-		/* Set l3_offset+flag only for known ethtypes */
-		prs->input_flags.l3 = 1;
-
-		/* Parse Layer 3 headers */
-		switch (prs->ethtype) {
-		case _ODP_ETHTYPE_IPV4:
-			prs->input_flags.ipv4 = 1;
-			prs->ip_proto = parse_ipv4(prs, &parseptr, &offset,
-						   frame_len);
-			break;
+	if (ethtype == _ODP_ETHTYPE_VLAN) {
+		prs->input_flags.vlan = 1;
+		vlan = (const _odp_vlanhdr_t *)parseptr;
+		ethtype = odp_be_to_cpu_16(vlan->type);
+		offset += sizeof(_odp_vlanhdr_t);
+		parseptr += sizeof(_odp_vlanhdr_t);
+	}
 
-		case _ODP_ETHTYPE_IPV6:
-			prs->input_flags.ipv6 = 1;
-			prs->ip_proto = parse_ipv6(prs, &parseptr, &offset,
-						   frame_len, seg_len);
-			break;
+	if (layer == ODP_PKTIO_PARSER_LAYER_L2)
+		return prs->error_flags.all != 0;
 
-		case _ODP_ETHTYPE_ARP:
-			prs->input_flags.arp = 1;
-			prs->ip_proto = 255;  /* Reserved invalid by IANA */
-			break;
+	/* Set l3_offset+flag only for known ethtypes */
+	prs->l3_offset = offset;
+	prs->input_flags.l3 = 1;
 
-		default:
-			prs->input_flags.l3 = 0;
-			prs->l3_offset = ODP_PACKET_OFFSET_INVALID;
-			prs->ip_proto = 255;  /* Reserved invalid by IANA */
-		}
+	/* Parse Layer 3 headers */
+	switch (ethtype) {
+	case _ODP_ETHTYPE_IPV4:
+		prs->input_flags.ipv4 = 1;
+		ip_proto = parse_ipv4(prs, &parseptr, &offset, frame_len);
+		break;
 
-		/* Set l4_offset+flag only for known ip_proto */
-		prs->l4_offset = offset;
-		prs->parsed_layers = LAYER_L3;
-		if (layer == LAYER_L3)
-			return prs->error_flags.all != 0;
-	}
-	/* Fall through */
+	case _ODP_ETHTYPE_IPV6:
+		prs->input_flags.ipv6 = 1;
+		ip_proto = parse_ipv6(prs, &parseptr, &offset, frame_len,
+				      seg_len);
+		break;
 
-	case LAYER_L4:
-	{
-		offset = prs->l4_offset;
-		parseptr = (const uint8_t *)(ptr + offset);
-		prs->input_flags.l4 = 1;
+	case _ODP_ETHTYPE_ARP:
+		prs->input_flags.arp = 1;
+		ip_proto = 255;  /* Reserved invalid by IANA */
+		break;
 
-		/* Parse Layer 4 headers */
-		switch (prs->ip_proto) {
-		case _ODP_IPPROTO_ICMPv4:
-		/* Fall through */
+	default:
+		prs->input_flags.l3 = 0;
+		prs->l3_offset = ODP_PACKET_OFFSET_INVALID;
+		ip_proto = 255;  /* Reserved invalid by IANA */
+	}
 
-		case _ODP_IPPROTO_ICMPv6:
-			prs->input_flags.icmp = 1;
-			break;
+	if (layer == ODP_PKTIO_PARSER_LAYER_L3)
+		return prs->error_flags.all != 0;
 
-		case _ODP_IPPROTO_TCP:
-			if (odp_unlikely(offset + _ODP_TCPHDR_LEN > seg_len))
-				return -1;
-			prs->input_flags.tcp = 1;
-			parse_tcp(prs, &parseptr, NULL);
-			break;
+	/* Set l4_offset+flag only for known ip_proto */
+	prs->l4_offset = offset;
+	prs->input_flags.l4 = 1;
 
-		case _ODP_IPPROTO_UDP:
-			if (odp_unlikely(offset + _ODP_UDPHDR_LEN > seg_len))
-				return -1;
-			prs->input_flags.udp = 1;
-			parse_udp(prs, &parseptr, NULL);
-			break;
+	/* Parse Layer 4 headers */
+	switch (ip_proto) {
+	case _ODP_IPPROTO_ICMPv4:
+	/* Fall through */
 
-		case _ODP_IPPROTO_AH:
-			prs->input_flags.ipsec = 1;
-			prs->input_flags.ipsec_ah = 1;
-			break;
+	case _ODP_IPPROTO_ICMPv6:
+		prs->input_flags.icmp = 1;
+		break;
 
-		case _ODP_IPPROTO_ESP:
-			prs->input_flags.ipsec = 1;
-			prs->input_flags.ipsec_esp = 1;
-			break;
+	case _ODP_IPPROTO_TCP:
+		if (odp_unlikely(offset + _ODP_TCPHDR_LEN > seg_len))
+			return -1;
+		prs->input_flags.tcp = 1;
+		parse_tcp(prs, &parseptr, NULL);
+		break;
 
-		case _ODP_IPPROTO_SCTP:
-			prs->input_flags.sctp = 1;
-			break;
+	case _ODP_IPPROTO_UDP:
+		if (odp_unlikely(offset + _ODP_UDPHDR_LEN > seg_len))
+			return -1;
+		prs->input_flags.udp = 1;
+		parse_udp(prs, &parseptr, NULL);
+		break;
 
-		default:
-			prs->input_flags.l4 = 0;
-			prs->l4_offset = ODP_PACKET_OFFSET_INVALID;
-			break;
-		}
+	case _ODP_IPPROTO_AH:
+		prs->input_flags.ipsec = 1;
+		prs->input_flags.ipsec_ah = 1;
+		break;
 
-		prs->parsed_layers = LAYER_L4;
+	case _ODP_IPPROTO_ESP:
+		prs->input_flags.ipsec = 1;
+		prs->input_flags.ipsec_esp = 1;
 		break;
-	}
 
-	case LAYER_ALL:
+	case _ODP_IPPROTO_SCTP:
+		prs->input_flags.sctp = 1;
 		break;
 
 	default:
-		ODP_ERR("Invalid parse layer: %d\n", (int)layer);
-		return -1;
+		prs->input_flags.l4 = 0;
+		prs->l4_offset = ODP_PACKET_OFFSET_INVALID;
+		break;
 	}
-
-	prs->parsed_layers = LAYER_ALL;
-
 parse_exit:
 	return prs->error_flags.all != 0;
 }
-
 /**
  * Simple packet parser
  */
-int packet_parse_layer(odp_packet_hdr_t *pkt_hdr, layer_t layer)
+int packet_parse_layer(odp_packet_hdr_t *pkt_hdr,
+		       odp_pktio_parser_layer_t layer)
 {
 	uint32_t seg_len = odp_packet_seg_len((odp_packet_t)pkt_hdr);
 	uint32_t len = packet_len(pkt_hdr);