linux-dpdk: porting commits from ODP for v1.12.0.0v1.12.0.0_DPDK_16.07

e72f532 linux-generic: packet: add fall through comments to parser
c710eb3 linux-generic: config: add missing doxygen documentation
for abi macros
b35abec fix out of tree build
5fff93c linux-gen: packet: identify sctp packets
f73efb1 linux-gen: packet: parse only required packet header layers
144a1d8 linux-gen: packet: enable parsing only selected packet header
layers

Signed-off-by: Balakrishna Garapati <balakrishna.garapati@linaro.org>
Reviewed-by: Maxim Uvarov <maxim.uvarov@linaro.org>

6 files changed, 263 insertions, 188 deletions

diff --git a/platform/linux-dpdk/Makefile.am b/platform/linux-dpdk/Makefile.am
index 488f2c02a..475ff027b 100644
--- a/platform/linux-dpdk/Makefile.am
+++ b/platform/linux-dpdk/Makefile.am
@@ -16,6 +16,7 @@ AM_CFLAGS +=  $(PLAT_CFLAGS)
 AM_CFLAGS +=  -I$(srcdir)/include
 AM_CFLAGS +=  -I$(top_srcdir)/platform/linux-generic/include
 AM_CFLAGS +=  -I$(top_srcdir)/include
+AM_CFLAGS +=  -I$(top_builddir)/include
 AM_CFLAGS +=  -Iinclude
 
 if SHARED_DPDK
diff --git a/platform/linux-dpdk/include/odp/api/plat/static_inline.h.in b/platform/linux-dpdk/include/odp/api/plat/static_inline.h.in
index acee5f3c1..4562a2251 100644
--- a/platform/linux-dpdk/include/odp/api/plat/static_inline.h.in
+++ b/platform/linux-dpdk/include/odp/api/plat/static_inline.h.in
@@ -17,6 +17,17 @@
 extern "C" {
 #endif
 
+/**
+ * @internal
+ * @def ODP_ABI_COMPAT
+ * Control ABI compatibility
+ */
+
+/**
+ * @internal
+ * @def _STATIC
+ * Control conditional static inline expansions for ABI compatibility
+ */
 #if @ODP_ABI_COMPAT@
 #define ODP_ABI_COMPAT 1
 #define _STATIC
diff --git a/platform/linux-dpdk/include/odp_packet_internal.h b/platform/linux-dpdk/include/odp_packet_internal.h
index 525966c4f..aa2e39c77 100644
--- a/platform/linux-dpdk/include/odp_packet_internal.h
+++ b/platform/linux-dpdk/include/odp_packet_internal.h
@@ -44,7 +44,6 @@ typedef union {
 
 	struct {
 		uint64_t parsed_l2:1; /**< L2 parsed */
-		uint64_t parsed_all:1;/**< Parsing complete */
 		uint64_t dst_queue:1; /**< Dst queue present */
 
 		uint64_t timestamp:1; /**< Timestamp present */
@@ -133,6 +132,18 @@ ODP_STATIC_ASSERT(sizeof(output_flags_t) == sizeof(uint32_t),
 		  "OUTPUT_FLAGS_SIZE_ERROR");
 
 /**
+ * Protocol stack layers
+ */
+typedef enum {
+	LAYER_NONE = 0,
+	LAYER_L1,
+	LAYER_L2,
+	LAYER_L3,
+	LAYER_L4,
+	LAYER_ALL
+} layer_t;
+
+/**
  * Packet parser metadata
  */
 typedef struct {
@@ -147,6 +158,10 @@ typedef struct {
 	uint32_t l3_len;    /**< Layer 3 length */
 	uint32_t l4_len;    /**< Layer 4 length */
 
+	layer_t parsed_layers;	/**< Highest parsed protocol stack layer */
+	uint16_t ethtype;	/**< EtherType */
+	uint8_t ip_proto;	/**< IP protocol */
+
 } packet_parser_t;
 
 /**
@@ -209,7 +224,7 @@ static inline int packet_parse_l2_not_done(packet_parser_t *prs)
 
 static inline int packet_parse_not_complete(odp_packet_hdr_t *pkt_hdr)
 {
-	return !pkt_hdr->p.input_flags.parsed_all;
+	return pkt_hdr->p.parsed_layers != LAYER_ALL;
 }
 
 /* Forward declarations */
@@ -237,12 +252,12 @@ static inline void _odp_packet_reset_parse(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	pkt_hdr->p.input_flags.parsed_all = 0;
+	pkt_hdr->p.parsed_layers = LAYER_NONE;
 	packet_parse_l2(&pkt_hdr->p, odp_packet_len(pkt));
 }
 
-/* Perform full packet parse */
-int packet_parse_full(odp_packet_hdr_t *pkt_hdr);
+/* Perform packet parse up to a given protocol layer */
+int packet_parse_layer(odp_packet_hdr_t *pkt_hdr, layer_t layer);
 
 /* Reset parser metadata for a new parse */
 void packet_parse_reset(odp_packet_hdr_t *pkt_hdr);
@@ -277,7 +292,7 @@ static inline void packet_set_ts(odp_packet_hdr_t *pkt_hdr, odp_time_t *ts)
 }
 
 int packet_parse_common(packet_parser_t *pkt_hdr, const uint8_t *ptr,
-			uint32_t pkt_len, uint32_t seg_len);
+			uint32_t pkt_len, uint32_t seg_len, layer_t layer);
 
 /* We can't enforce tailroom reservation for received packets */
 ODP_STATIC_ASSERT(ODP_CONFIG_PACKET_TAILROOM == 0,
diff --git a/platform/linux-dpdk/odp_packet.c b/platform/linux-dpdk/odp_packet.c
index 7cb294eb1..74864138c 100644
--- a/platform/linux-dpdk/odp_packet.c
+++ b/platform/linux-dpdk/odp_packet.c
@@ -75,12 +75,13 @@ ODP_STATIC_ASSERT(sizeof(dummy.ol_flags) == sizeof(uint64_t),
 static inline void packet_parse_disable(odp_packet_hdr_t *pkt_hdr)
 {
 	pkt_hdr->p.input_flags.parsed_l2  = 1;
-	pkt_hdr->p.input_flags.parsed_all = 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;
@@ -194,6 +195,7 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len)
 	       ODP_OFFSETOF(odp_packet_hdr_t, uarea_size) -
 	       ODP_OFFSETOF(odp_packet_hdr_t, input));
 
+	pkt_hdr->p.parsed_layers    = LAYER_NONE;
 	pkt_hdr->p.l3_offset = (uint32_t)ODP_PACKET_OFFSET_INVALID;
 	pkt_hdr->p.l4_offset = (uint32_t)ODP_PACKET_OFFSET_INVALID;
 	pkt_hdr->buf_hdr.next = NULL;
@@ -643,8 +645,8 @@ void *odp_packet_l3_ptr(odp_packet_t pkt, uint32_t *len)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	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);
 }
 
@@ -652,8 +654,8 @@ uint32_t odp_packet_l3_offset(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	if (pkt_hdr->p.parsed_layers < LAYER_L3)
+		packet_parse_layer(pkt_hdr, LAYER_L3);
 	return pkt_hdr->p.l3_offset;
 }
 
@@ -664,8 +666,8 @@ 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 (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	if (pkt_hdr->p.parsed_layers < LAYER_L3)
+		packet_parse_layer(pkt_hdr, LAYER_L3);
 	pkt_hdr->p.l3_offset = offset;
 	return 0;
 }
@@ -674,8 +676,8 @@ void *odp_packet_l4_ptr(odp_packet_t pkt, uint32_t *len)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	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);
 }
 
@@ -683,8 +685,8 @@ uint32_t odp_packet_l4_offset(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	if (pkt_hdr->p.parsed_layers < LAYER_L4)
+		packet_parse_layer(pkt_hdr, LAYER_L4);
 	return pkt_hdr->p.l4_offset;
 }
 
@@ -695,8 +697,8 @@ 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 (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	if (pkt_hdr->p.parsed_layers < LAYER_L4)
+		packet_parse_layer(pkt_hdr, LAYER_L4);
 	pkt_hdr->p.l4_offset = offset;
 	return 0;
 }
@@ -1303,162 +1305,207 @@ static inline void parse_udp(packet_parser_t *prs,
 }
 
 /**
- * Parse common packet headers
+ * Parse common packet headers up to given layer
  *
  * The function expects at least PACKET_PARSE_SEG_LEN bytes of data to be
  * available from the ptr.
  */
 int packet_parse_common(packet_parser_t *prs, const uint8_t *ptr,
-			uint32_t frame_len, uint32_t seg_len)
+			uint32_t frame_len, uint32_t seg_len, layer_t layer)
 {
-	const _odp_ethhdr_t *eth;
-	const _odp_vlanhdr_t *vlan;
-	uint16_t ethtype;
 	uint32_t offset;
-	uint8_t ip_proto = 0;
 	const uint8_t *parseptr;
-	uint16_t macaddr0, macaddr2, macaddr4;
-
-	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 */
-	ethtype = odp_be_to_cpu_16(eth->type);
-	parseptr = (const uint8_t *)(eth + 1);
+	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);
 
-	/* 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;
+		/* 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;
 		}
-		ethtype = odp_be_to_cpu_16(*((const uint16_t *)
-					     (uintptr_t)(parseptr + 6)));
-		offset   += 8;
-		parseptr += 8;
-	}
 
-	/* Parse the VLAN header(s), if present */
-	if (ethtype == _ODP_ETHTYPE_VLAN_OUTER) {
-		prs->input_flags.vlan_qinq = 1;
-		prs->input_flags.vlan = 1;
+		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);
+		}
 
-		vlan = (const _odp_vlanhdr_t *)parseptr;
-		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 (prs->ethtype == _ODP_ETHTYPE_VLAN_OUTER) {
+			prs->input_flags.vlan_qinq = 1;
+			prs->input_flags.vlan = 1;
 
-	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);
-	}
+			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);
+		}
 
-	/* Set l3_offset+flag only for known ethtypes */
-	prs->input_flags.l3 = 1;
-	prs->l3_offset = offset;
+		prs->l3_offset = offset;
+		prs->parsed_layers = LAYER_L2;
+		if (layer == LAYER_L2)
+			return prs->error_flags.all != 0;
+	}
+	/* 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;
 
-	/* 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;
+		case _ODP_ETHTYPE_IPV6:
+			prs->input_flags.ipv6 = 1;
+			prs->ip_proto = parse_ipv6(prs, &parseptr, &offset,
+						   frame_len, seg_len);
+			break;
 
-	case _ODP_ETHTYPE_IPV6:
-		prs->input_flags.ipv6 = 1;
-		ip_proto = parse_ipv6(prs, &parseptr, &offset, frame_len,
-				      seg_len);
-		break;
+		case _ODP_ETHTYPE_ARP:
+			prs->input_flags.arp = 1;
+			prs->ip_proto = 255;  /* Reserved invalid by IANA */
+			break;
 
-	case _ODP_ETHTYPE_ARP:
-		prs->input_flags.arp = 1;
-		ip_proto = 255;  /* Reserved invalid by IANA */
-		break;
+		default:
+			prs->input_flags.l3 = 0;
+			prs->l3_offset = ODP_PACKET_OFFSET_INVALID;
+			prs->ip_proto = 255;  /* Reserved invalid by IANA */
+		}
 
-	default:
-		prs->input_flags.l3 = 0;
-		prs->l3_offset = ODP_PACKET_OFFSET_INVALID;
-		ip_proto = 255;  /* Reserved invalid by IANA */
+		/* 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 LAYER_L4:
+	{
+		offset = prs->l4_offset;
+		parseptr = (const uint8_t *)(ptr + offset);
+		prs->input_flags.l4 = 1;
+
+		/* Parse Layer 4 headers */
+		switch (prs->ip_proto) {
+		case _ODP_IPPROTO_ICMP:
+			prs->input_flags.icmp = 1;
+			break;
 
-	/* Set l4_offset+flag only for known ip_proto */
-	prs->input_flags.l4 = 1;
-	prs->l4_offset = offset;
+		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;
 
-	/* Parse Layer 4 headers */
-	switch (ip_proto) {
-	case _ODP_IPPROTO_ICMP:
-		prs->input_flags.icmp = 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;
 
-	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_AH:
+			prs->input_flags.ipsec = 1;
+			prs->input_flags.ipsec_ah = 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;
+		case _ODP_IPPROTO_ESP:
+			prs->input_flags.ipsec = 1;
+			prs->input_flags.ipsec_esp = 1;
+			break;
+
+		case _ODP_IPPROTO_SCTP:
+			prs->input_flags.sctp = 1;
+			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;
+		prs->parsed_layers = LAYER_L4;
 		break;
+	}
 
-	case _ODP_IPPROTO_ESP:
-		prs->input_flags.ipsec = 1;
-		prs->input_flags.ipsec_esp = 1;
+	case LAYER_ALL:
 		break;
 
 	default:
-		prs->input_flags.l4 = 0;
-		prs->l4_offset = ODP_PACKET_OFFSET_INVALID;
-		break;
+		ODP_ERR("Invalid parse layer: %d\n", (int)layer);
+		return -1;
 	}
 
+	prs->parsed_layers = LAYER_ALL;
+
 parse_exit:
-	prs->input_flags.parsed_all = 1;
 	return prs->error_flags.all != 0;
 }
 
 /**
  * Simple packet parser
  */
-int packet_parse_full(odp_packet_hdr_t *pkt_hdr)
+int packet_parse_layer(odp_packet_hdr_t *pkt_hdr, layer_t layer)
 {
 	uint32_t seg_len = odp_packet_seg_len((odp_packet_t)pkt_hdr);
 	uint32_t len = packet_len(pkt_hdr);
 	void *base = odp_packet_data((odp_packet_t)pkt_hdr);
 
-	return packet_parse_common(&pkt_hdr->p, base, len, seg_len);
+	return packet_parse_common(&pkt_hdr->p, base, len, seg_len, layer);
 }
diff --git a/platform/linux-dpdk/odp_packet_flags.c b/platform/linux-dpdk/odp_packet_flags.c
index 964f45ef0..18c30bb15 100644
--- a/platform/linux-dpdk/odp_packet_flags.c
+++ b/platform/linux-dpdk/odp_packet_flags.c
@@ -11,17 +11,17 @@
 #include <odp/api/plat/packet_flags_inlines.h>
 #endif
 
-#define retflag(pkt, x) do {                             \
+#define retflag(pkt, x, layer) do {                      \
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt); \
-	if (packet_parse_not_complete(pkt_hdr))          \
-		packet_parse_full(pkt_hdr);              \
+	if (pkt_hdr->p.parsed_layers < layer)            \
+		packet_parse_layer(pkt_hdr, layer);      \
 	return pkt_hdr->p.x;                             \
 	} while (0)
 
-#define setflag(pkt, x, v) do {                          \
+#define setflag(pkt, x, v, layer) do {                   \
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt); \
-	if (packet_parse_not_complete(pkt_hdr))          \
-		packet_parse_full(pkt_hdr);              \
+	if (pkt_hdr->p.parsed_layers < layer)            \
+		packet_parse_layer(pkt_hdr, layer);      \
 	pkt_hdr->p.x = v & 1;                            \
 	} while (0)
 
@@ -29,7 +29,7 @@ int odp_packet_has_error(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+		packet_parse_layer(pkt_hdr, LAYER_ALL);
 	return odp_packet_hdr(pkt)->p.error_flags.all != 0;
 }
 
@@ -54,7 +54,7 @@ int odp_packet_has_l2_error(odp_packet_t pkt)
 
 int odp_packet_has_l3(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.l3);
+	retflag(pkt, input_flags.l3, LAYER_L3);
 }
 
 int odp_packet_has_l3_error(odp_packet_t pkt)
@@ -62,22 +62,22 @@ int odp_packet_has_l3_error(odp_packet_t pkt)
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
 	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+		packet_parse_layer(pkt_hdr, LAYER_ALL);
 
 	return pkt_hdr->p.error_flags.ip_err;
 }
 
 int odp_packet_has_l4(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.l4);
+	retflag(pkt, input_flags.l4, LAYER_L4);
 }
 
 int odp_packet_has_l4_error(odp_packet_t pkt)
 {
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
-	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+	if (pkt_hdr->p.parsed_layers < LAYER_L4)
+		packet_parse_layer(pkt_hdr, LAYER_L4);
 
 	return pkt_hdr->p.error_flags.tcp_err | pkt_hdr->p.error_flags.udp_err;
 }
@@ -91,12 +91,12 @@ int odp_packet_has_eth(odp_packet_t pkt)
 
 int odp_packet_has_eth_bcast(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.eth_bcast);
+	retflag(pkt, input_flags.eth_bcast, LAYER_L2);
 }
 
 int odp_packet_has_eth_mcast(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.eth_mcast);
+	retflag(pkt, input_flags.eth_mcast, LAYER_L2);
 }
 
 int odp_packet_has_jumbo(odp_packet_t pkt)
@@ -108,72 +108,72 @@ int odp_packet_has_jumbo(odp_packet_t pkt)
 
 int odp_packet_has_vlan(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.vlan);
+	retflag(pkt, input_flags.vlan, LAYER_L2);
 }
 
 int odp_packet_has_vlan_qinq(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.vlan_qinq);
+	retflag(pkt, input_flags.vlan_qinq, LAYER_L2);
 }
 
 int odp_packet_has_arp(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.arp);
+	retflag(pkt, input_flags.arp, LAYER_L3);
 }
 
 int odp_packet_has_ipv4(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ipv4);
+	retflag(pkt, input_flags.ipv4, LAYER_L3);
 }
 
 int odp_packet_has_ipv6(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ipv6);
+	retflag(pkt, input_flags.ipv6, LAYER_L3);
 }
 
 int odp_packet_has_ip_bcast(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ip_bcast);
+	retflag(pkt, input_flags.ip_bcast, LAYER_L3);
 }
 
 int odp_packet_has_ip_mcast(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ip_mcast);
+	retflag(pkt, input_flags.ip_mcast, LAYER_L3);
 }
 
 int odp_packet_has_ipfrag(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ipfrag);
+	retflag(pkt, input_flags.ipfrag, LAYER_L3);
 }
 
 int odp_packet_has_ipopt(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ipopt);
+	retflag(pkt, input_flags.ipopt, LAYER_L3);
 }
 
 int odp_packet_has_ipsec(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.ipsec);
+	retflag(pkt, input_flags.ipsec, LAYER_L4);
 }
 
 int odp_packet_has_udp(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.udp);
+	retflag(pkt, input_flags.udp, LAYER_L4);
 }
 
 int odp_packet_has_tcp(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.tcp);
+	retflag(pkt, input_flags.tcp, LAYER_L4);
 }
 
 int odp_packet_has_sctp(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.sctp);
+	retflag(pkt, input_flags.sctp, LAYER_L4);
 }
 
 int odp_packet_has_icmp(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.icmp);
+	retflag(pkt, input_flags.icmp, LAYER_L4);
 }
 
 int odp_packet_has_ts(odp_packet_t pkt)
@@ -185,7 +185,7 @@ int odp_packet_has_ts(odp_packet_t pkt)
 
 odp_packet_color_t odp_packet_color(odp_packet_t pkt)
 {
-	retflag(pkt, input_flags.color);
+	retflag(pkt, input_flags.color, LAYER_ALL);
 }
 
 void odp_packet_color_set(odp_packet_t pkt, odp_packet_color_t color)
@@ -193,7 +193,7 @@ void odp_packet_color_set(odp_packet_t pkt, odp_packet_color_t color)
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
 	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+		packet_parse_layer(pkt_hdr, LAYER_ALL);
 
 	pkt_hdr->p.input_flags.color = color;
 }
@@ -203,19 +203,19 @@ odp_bool_t odp_packet_drop_eligible(odp_packet_t pkt)
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
 	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+		packet_parse_layer(pkt_hdr, LAYER_ALL);
 
 	return !pkt_hdr->p.input_flags.nodrop;
 }
 
 void odp_packet_drop_eligible_set(odp_packet_t pkt, odp_bool_t drop)
 {
-	setflag(pkt, input_flags.nodrop, !drop);
+	setflag(pkt, input_flags.nodrop, !drop, LAYER_ALL);
 }
 
 int8_t odp_packet_shaper_len_adjust(odp_packet_t pkt)
 {
-	retflag(pkt, output_flags.shaper_len_adj);
+	retflag(pkt, output_flags.shaper_len_adj, LAYER_ALL);
 }
 
 void odp_packet_shaper_len_adjust_set(odp_packet_t pkt, int8_t adj)
@@ -223,7 +223,7 @@ void odp_packet_shaper_len_adjust_set(odp_packet_t pkt, int8_t adj)
 	odp_packet_hdr_t *pkt_hdr = odp_packet_hdr(pkt);
 
 	if (packet_parse_not_complete(pkt_hdr))
-		packet_parse_full(pkt_hdr);
+		packet_parse_layer(pkt_hdr, LAYER_ALL);
 
 	pkt_hdr->p.output_flags.shaper_len_adj = adj;
 }
@@ -232,107 +232,107 @@ void odp_packet_shaper_len_adjust_set(odp_packet_t pkt, int8_t adj)
 
 void odp_packet_has_l2_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.l2, val);
+	setflag(pkt, input_flags.l2, val, LAYER_L2);
 }
 
 void odp_packet_has_l3_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.l3, val);
+	setflag(pkt, input_flags.l3, val, LAYER_L3);
 }
 
 void odp_packet_has_l4_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.l4, val);
+	setflag(pkt, input_flags.l4, val, LAYER_L4);
 }
 
 void odp_packet_has_eth_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.eth, val);
+	setflag(pkt, input_flags.eth, val, LAYER_L2);
 }
 
 void odp_packet_has_eth_bcast_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.eth_bcast, val);
+	setflag(pkt, input_flags.eth_bcast, val, LAYER_L2);
 }
 
 void odp_packet_has_eth_mcast_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.eth_mcast, val);
+	setflag(pkt, input_flags.eth_mcast, val, LAYER_L2);
 }
 
 void odp_packet_has_jumbo_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.jumbo, val);
+	setflag(pkt, input_flags.jumbo, val, LAYER_L2);
 }
 
 void odp_packet_has_vlan_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.vlan, val);
+	setflag(pkt, input_flags.vlan, val, LAYER_L2);
 }
 
 void odp_packet_has_vlan_qinq_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.vlan_qinq, val);
+	setflag(pkt, input_flags.vlan_qinq, val, LAYER_L2);
 }
 
 void odp_packet_has_arp_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.arp, val);
+	setflag(pkt, input_flags.arp, val, LAYER_L3);
 }
 
 void odp_packet_has_ipv4_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ipv4, val);
+	setflag(pkt, input_flags.ipv4, val, LAYER_L3);
 }
 
 void odp_packet_has_ipv6_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ipv6, val);
+	setflag(pkt, input_flags.ipv6, val, LAYER_L3);
 }
 
 void odp_packet_has_ip_bcast_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ip_bcast, val);
+	setflag(pkt, input_flags.ip_bcast, val, LAYER_L3);
 }
 
 void odp_packet_has_ip_mcast_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ip_mcast, val);
+	setflag(pkt, input_flags.ip_mcast, val, LAYER_L3);
 }
 
 void odp_packet_has_ipfrag_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ipfrag, val);
+	setflag(pkt, input_flags.ipfrag, val, LAYER_L3);
 }
 
 void odp_packet_has_ipopt_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ipopt, val);
+	setflag(pkt, input_flags.ipopt, val, LAYER_L3);
 }
 
 void odp_packet_has_ipsec_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.ipsec, val);
+	setflag(pkt, input_flags.ipsec, val, LAYER_L4);
 }
 
 void odp_packet_has_udp_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.udp, val);
+	setflag(pkt, input_flags.udp, val, LAYER_L4);
 }
 
 void odp_packet_has_tcp_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.tcp, val);
+	setflag(pkt, input_flags.tcp, val, LAYER_L4);
 }
 
 void odp_packet_has_sctp_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.sctp, val);
+	setflag(pkt, input_flags.sctp, val, LAYER_L4);
 }
 
 void odp_packet_has_icmp_set(odp_packet_t pkt, int val)
 {
-	setflag(pkt, input_flags.icmp, val);
+	setflag(pkt, input_flags.icmp, val, LAYER_L4);
 }
 
 void odp_packet_has_ts_clr(odp_packet_t pkt)
diff --git a/test/linux-dpdk/Makefile.inc b/test/linux-dpdk/Makefile.inc
index 8f63d0195..b3799724d 100644
--- a/test/linux-dpdk/Makefile.inc
+++ b/test/linux-dpdk/Makefile.inc
@@ -10,6 +10,7 @@ LIBODP = $(LIB)/libodphelper-linux.la $(LIB)/libodp-dpdk.la
 
 INCCUNIT_COMMON = -I$(top_srcdir)/test/common_plat/common
 INCODP = -I$(top_builddir)/platform/@with_platform@/include \
+	 -I$(top_builddir)/include \
 	 -I$(top_srcdir)/helper/include \
 	 -I$(top_srcdir)/include \
 	 -I$(top_srcdir)/platform/@with_platform@/arch/$(ARCH_DIR) \