From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <dev-bounces@dpdk.org>
Received: from dpdk.org (dpdk.org [92.243.14.124])
	by inbox.dpdk.org (Postfix) with ESMTP id 71F9EA04B1;
	Tue,  8 Sep 2020 22:17:02 +0200 (CEST)
Received: from [92.243.14.124] (localhost [127.0.0.1])
	by dpdk.org (Postfix) with ESMTP id B16921C0CA;
	Tue,  8 Sep 2020 22:16:48 +0200 (CEST)
Received: from hqnvemgate26.nvidia.com (hqnvemgate26.nvidia.com
 [216.228.121.65]) by dpdk.org (Postfix) with ESMTP id 2BBB71C0CA
 for <dev@dpdk.org>; Tue,  8 Sep 2020 22:16:47 +0200 (CEST)
Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by
 hqnvemgate26.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA)
 id <B5f57e6a10001>; Tue, 08 Sep 2020 13:16:33 -0700
Received: from hqmail.nvidia.com ([172.20.161.6])
 by hqpgpgate101.nvidia.com (PGP Universal service);
 Tue, 08 Sep 2020 13:16:46 -0700
X-PGP-Universal: processed;
 by hqpgpgate101.nvidia.com on Tue, 08 Sep 2020 13:16:46 -0700
Received: from nvidia.com (10.124.1.5) by HQMAIL107.nvidia.com (172.20.187.13)
 with Microsoft SMTP Server (TLS) id 15.0.1473.3;
 Tue, 8 Sep 2020 20:16:28 +0000
From: Gregory Etelson <getelson@nvidia.com>
To: <dev@dpdk.org>
CC: <matan@nvidia.com>, <rasland@nvidia.com>, <orika@nvidia.com>, Ori Kam
 <orika@mellanox.com>, Wenzhuo Lu <wenzhuo.lu@intel.com>, Beilei Xing
 <beilei.xing@intel.com>, Bernard Iremonger <bernard.iremonger@intel.com>
Date: Tue, 8 Sep 2020 23:15:51 +0300
Message-ID: <20200908201552.14423-5-getelson@nvidia.com>
X-Mailer: git-send-email 2.25.1
In-Reply-To: <20200908201552.14423-1-getelson@nvidia.com>
References: <20200625160348.26220-1-getelson@mellanox.com>
 <20200908201552.14423-1-getelson@nvidia.com>
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain
X-Originating-IP: [10.124.1.5]
X-ClientProxiedBy: HQMAIL101.nvidia.com (172.20.187.10) To
 HQMAIL107.nvidia.com (172.20.187.13)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1;
 t=1599596193; bh=UmqsGd3nkRGKbKGN34zJmTDUWPiUuU/CASLTbQB43pw=;
 h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer:
 In-Reply-To:References:MIME-Version:Content-Transfer-Encoding:
 Content-Type:X-Originating-IP:X-ClientProxiedBy;
 b=j7tBLWTlMiqb7oYA2EjTLdv+49ufyGqWzocikQprha9cBY8Q26QbJUOfaJPhAgjm1
 qHJqL88tW/VYBRHsUwqAD7GuqMOO0b3AFQr4chYFS2bBDCjWDEqaNdmTWhU5d2PLS8
 dMDqgqvw2Y/cBUWVkgUNjem81BYhnFAmzqJx0lh67x6bA1GeJ4H/vmN54jpN+YHi/m
 cLLgsypi5xXwz1Nj+8t+syeuEDGsUKQ121QF60PIcBwA2MhldXwqkPyL3/RuHVEEEw
 ZxlZ95pIp1un7alV9q/x2uT/u8OlNOghgTSq3L9LJs4BeGNSN12fsEGymONnKdTqpH
 3pfAvv0qdS18A==
Subject: [dpdk-dev] [PATCH v2 4/4] app/testpmd: support tunnel offload API
X-BeenThere: dev@dpdk.org
X-Mailman-Version: 2.1.15
Precedence: list
List-Id: DPDK patches and discussions <dev.dpdk.org>
List-Unsubscribe: <https://mails.dpdk.org/options/dev>,
 <mailto:dev-request@dpdk.org?subject=unsubscribe>
List-Archive: <http://mails.dpdk.org/archives/dev/>
List-Post: <mailto:dev@dpdk.org>
List-Help: <mailto:dev-request@dpdk.org?subject=help>
List-Subscribe: <https://mails.dpdk.org/listinfo/dev>,
 <mailto:dev-request@dpdk.org?subject=subscribe>
Errors-To: dev-bounces@dpdk.org
Sender: "dev" <dev-bounces@dpdk.org>

Tunnel Offload API provides hardware independent, unified model
to offload tunneled traffic. Key model elements are:
 - apply matches to both outer and inner packet headers
   during entire offload procedure;
 - restore outer header of partially offloaded packet;
 - model is implemented as a set of helper functions.

Implementation details:

* Create application tunnel:
flow tunnel <port> type <tunnel type>
On success, the command creates application tunnel object and returns
the tunnel descriptor. Tunnel descriptor is used in subsequent flow
creation commands to reference the tunnel.

* Create tunnel steering flow rule:
tunnel_set <tunnel descriptor> parameter used with steering rule
template.

* Create tunnel matching flow rule:
tunnel_match <tunnel descriptor> used with matching rule template.

* If tunnel steering rule was offloaded, outer header of a partially
offloaded packet is restored after miss.

Example:
test packet=3D
<Ether  dst=3D24:8a:07:8d:ae:d6 src=3D50:6b:4b:cc:fc:e2 type=3DIPv4 |
<IP  version=3D4 ihl=3D5 proto=3Dudp src=3D1.1.1.1 dst=3D1.1.1.10 |
<UDP  sport=3D4789 dport=3D4789 len=3D58 chksum=3D0x7f7b |
<VXLAN  NextProtocol=3DEthernet vni=3D0x0 |
<Ether  dst=3D24:aa:aa:aa:aa:d6 src=3D50:bb:bb:bb:bb:e2 type=3DIPv4 |
<IP  version=3D4 ihl=3D5 proto=3Dicmp src=3D2.2.2.2 dst=3D2.2.2.200 |
<ICMP  type=3Decho-request code=3D0 chksum=3D0xf7ff id=3D0x0 seq=3D0x0 |>>>=
>>>>
>>> len(packet)
92

testpmd> flow flush 0
testpmd> port 0/queue 0: received 1 packets
src=3D50:6B:4B:CC:FC:E2 - dst=3D24:8A:07:8D:AE:D6 - type=3D0x0800 -
length=3D92

testpmd> flow tunnel 0 type vxlan
port 0: flow tunnel #1 type vxlan
testpmd> flow create 0 ingress group 0 tunnel_set 1
         pattern eth /ipv4 / udp dst is 4789 / vxlan / end
         actions  jump group 0 / end
Flow rule #0 created
testpmd> port 0/queue 0: received 1 packets
tunnel restore info: - vxlan tunnel - outer header present # <--
  src=3D50:6B:4B:CC:FC:E2 - dst=3D24:8A:07:8D:AE:D6 - type=3D0x0800 -
length=3D92

testpmd> flow create 0 ingress group 0 tunnel_match 1
         pattern eth / ipv4 / udp dst is 4789 / vxlan / eth / ipv4 /
         end
         actions set_mac_dst mac_addr 02:CA:FE:CA:FA:80 /
         queue index 0 / end
Flow rule #1 created
testpmd> port 0/queue 0: received 1 packets
  src=3D50:BB:BB:BB:BB:E2 - dst=3D02:CA:FE:CA:FA:80 - type=3D0x0800 -
length=3D42

TODO: add tunnel destruction command.

Signed-off-by: Gregory Etelson <getelson@nvidia.com>
---
v2:
* introduce testpmd support for tunnel offload API
---
 app/test-pmd/cmdline_flow.c | 102 ++++++++++++++++++++++++-
 app/test-pmd/config.c       | 147 +++++++++++++++++++++++++++++++++++-
 app/test-pmd/testpmd.c      |   5 +-
 app/test-pmd/testpmd.h      |  27 ++++++-
 app/test-pmd/util.c         |  30 +++++++-
 5 files changed, 302 insertions(+), 9 deletions(-)

diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
index 6263d307ed..f0a7a4a9ea 100644
--- a/app/test-pmd/cmdline_flow.c
+++ b/app/test-pmd/cmdline_flow.c
@@ -69,6 +69,10 @@ enum index {
 	LIST,
 	AGED,
 	ISOLATE,
+	TUNNEL,
+
+	/* Tunnel argumens. */
+	TUNNEL_RULE,
=20
 	/* Destroy arguments. */
 	DESTROY_RULE,
@@ -88,6 +92,8 @@ enum index {
 	INGRESS,
 	EGRESS,
 	TRANSFER,
+	TUNNEL_SET,
+	TUNNEL_MATCH,
=20
 	/* Validate/create pattern. */
 	PATTERN,
@@ -653,6 +659,7 @@ struct buffer {
 	union {
 		struct {
 			struct rte_flow_attr attr;
+			struct tunnel_ops tunnel_ops;
 			struct rte_flow_item *pattern;
 			struct rte_flow_action *actions;
 			uint32_t pattern_n;
@@ -713,10 +720,18 @@ static const enum index next_vc_attr[] =3D {
 	INGRESS,
 	EGRESS,
 	TRANSFER,
+	TUNNEL_SET,
+	TUNNEL_MATCH,
 	PATTERN,
 	ZERO,
 };
=20
+static const enum index next_tunnel_attr[] =3D {
+	TUNNEL_RULE,
+	END,
+	ZERO,
+};
+
 static const enum index next_destroy_attr[] =3D {
 	DESTROY_RULE,
 	END,
@@ -1516,6 +1531,9 @@ static int parse_aged(struct context *, const struct =
token *,
 static int parse_isolate(struct context *, const struct token *,
 			 const char *, unsigned int,
 			 void *, unsigned int);
+static int parse_tunnel(struct context *, const struct token *,
+			const char *, unsigned int,
+			void *, unsigned int);
 static int parse_int(struct context *, const struct token *,
 		     const char *, unsigned int,
 		     void *, unsigned int);
@@ -1698,7 +1716,8 @@ static const struct token token_list[] =3D {
 			      LIST,
 			      AGED,
 			      QUERY,
-			      ISOLATE)),
+			      ISOLATE,
+			      TUNNEL)),
 		.call =3D parse_init,
 	},
 	/* Sub-level commands. */
@@ -1772,6 +1791,21 @@ static const struct token token_list[] =3D {
 			     ARGS_ENTRY(struct buffer, port)),
 		.call =3D parse_isolate,
 	},
+	[TUNNEL] =3D {
+		.name =3D "tunnel",
+		.help =3D "new tunnel API",
+		.next =3D NEXT(NEXT_ENTRY(TUNNEL_RULE), NEXT_ENTRY(PORT_ID)),
+		.args =3D ARGS(ARGS_ENTRY(struct buffer, port)),
+		.call =3D parse_tunnel,
+	},
+	/* Tunnel arguments. */
+	[TUNNEL_RULE]{
+		.name =3D "type",
+		.help =3D "specify tunnel type",
+		.next =3D NEXT(next_tunnel_attr, NEXT_ENTRY(FILE_PATH)),
+		.args =3D ARGS(ARGS_ENTRY(struct tunnel_ops, type)),
+		.call =3D parse_tunnel,
+	},
 	/* Destroy arguments. */
 	[DESTROY_RULE] =3D {
 		.name =3D "rule",
@@ -1835,6 +1869,20 @@ static const struct token token_list[] =3D {
 		.next =3D NEXT(next_vc_attr),
 		.call =3D parse_vc,
 	},
+	[TUNNEL_SET] =3D {
+		.name =3D "tunnel_set",
+		.help =3D "tunnel steer rule",
+		.next =3D NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)),
+		.args =3D ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
+		.call =3D parse_vc,
+	},
+	[TUNNEL_MATCH] =3D {
+		.name =3D "tunnel_match",
+		.help =3D "tunnel match rule",
+		.next =3D NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)),
+		.args =3D ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
+		.call =3D parse_vc,
+	},
 	/* Validate/create pattern. */
 	[PATTERN] =3D {
 		.name =3D "pattern",
@@ -4054,12 +4102,28 @@ parse_vc(struct context *ctx, const struct token *t=
oken,
 		return len;
 	}
 	ctx->objdata =3D 0;
-	ctx->object =3D &out->args.vc.attr;
+	switch (ctx->curr) {
+	default:
+		ctx->object =3D &out->args.vc.attr;
+		break;
+	case TUNNEL_SET:
+	case TUNNEL_MATCH:
+		ctx->object =3D &out->args.vc.tunnel_ops;
+		break;
+	}
 	ctx->objmask =3D NULL;
 	switch (ctx->curr) {
 	case GROUP:
 	case PRIORITY:
 		return len;
+	case TUNNEL_SET:
+		out->args.vc.tunnel_ops.enabled =3D 1;
+		out->args.vc.tunnel_ops.actions =3D 1;
+		return len;
+	case TUNNEL_MATCH:
+		out->args.vc.tunnel_ops.enabled =3D 1;
+		out->args.vc.tunnel_ops.items =3D 1;
+		return len;
 	case INGRESS:
 		out->args.vc.attr.ingress =3D 1;
 		return len;
@@ -5597,6 +5661,34 @@ parse_isolate(struct context *ctx, const struct toke=
n *token,
 	return len;
 }
=20
+static int
+parse_tunnel(struct context *ctx, const struct token *token,
+	     const char *str, unsigned int len,
+	     void *buf, unsigned int size)
+{
+	struct buffer *out =3D buf;
+
+	/* Token name must match. */
+	if (parse_default(ctx, token, str, len, NULL, 0) < 0)
+		return -1;
+	/* Nothing else to do if there is no buffer. */
+	if (!out)
+		return len;
+	if (!out->command) {
+		if (ctx->curr !=3D TUNNEL)
+			return -1;
+		if (sizeof(*out) > size)
+			return -1;
+		out->command =3D ctx->curr;
+		ctx->objdata =3D 0;
+		ctx->object =3D out;
+		ctx->objmask =3D NULL;
+	}
+	if (ctx->curr =3D=3D TUNNEL_RULE)
+		ctx->object =3D &out->args.vc.tunnel_ops;
+	return len;
+}
+
 /**
  * Parse signed/unsigned integers 8 to 64-bit long.
  *
@@ -6547,7 +6639,8 @@ cmd_flow_parsed(const struct buffer *in)
 		break;
 	case CREATE:
 		port_flow_create(in->port, &in->args.vc.attr,
-				 in->args.vc.pattern, in->args.vc.actions);
+				 in->args.vc.pattern, in->args.vc.actions,
+				 &in->args.vc.tunnel_ops);
 		break;
 	case DESTROY:
 		port_flow_destroy(in->port, in->args.destroy.rule_n,
@@ -6573,6 +6666,9 @@ cmd_flow_parsed(const struct buffer *in)
 	case AGED:
 		port_flow_aged(in->port, in->args.aged.destroy);
 		break;
+	case TUNNEL:
+		port_flow_add_tunnel(in->port, &in->args.vc.tunnel_ops);
+		break;
 	default:
 		break;
 	}
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 30bee33248..b90927f451 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -1337,6 +1337,58 @@ port_mtu_set(portid_t port_id, uint16_t mtu)
=20
 /* Generic flow management functions. */
=20
+static struct port_flow_tunnel *
+port_flow_locate_tunnel(struct rte_port *port, uint32_t port_tunnel_id)
+{
+	struct port_flow_tunnel *flow_tunnel;
+
+	LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
+		if (flow_tunnel->id =3D=3D port_tunnel_id)
+			goto out;
+	}
+	flow_tunnel =3D NULL;
+
+out:
+	return flow_tunnel;
+}
+
+void port_flow_release_tunnel(struct port_flow_tunnel *flow_tunnel)
+{
+	LIST_REMOVE(flow_tunnel, chain);
+	free(flow_tunnel);
+}
+
+void port_flow_add_tunnel(portid_t port_id, const struct tunnel_ops *ops)
+{
+	struct rte_port *port =3D &ports[port_id];
+	enum rte_flow_item_type	type;
+	struct port_flow_tunnel *flow_tunnel;
+
+	if (!strncmp(ops->type, "vxlan", strlen("vxlan")))
+		type =3D RTE_FLOW_ITEM_TYPE_VXLAN;
+	else {
+		printf("cannot offload \"%s\" tunnel type\n", ops->type);
+		return;
+	}
+	LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
+		if (flow_tunnel->tunnel.type =3D=3D type)
+			break;
+	}
+	if (!flow_tunnel) {
+		flow_tunnel =3D calloc(1, sizeof(*flow_tunnel));
+		if (!flow_tunnel) {
+			printf("failed to allocate port flow_tunnel object\n");
+			return;
+		}
+		flow_tunnel->tunnel.type =3D type;
+		flow_tunnel->id =3D LIST_EMPTY(&port->flow_tunnel_list) ? 1 :
+				  LIST_FIRST(&port->flow_tunnel_list)->id + 1;
+		LIST_INSERT_HEAD(&port->flow_tunnel_list, flow_tunnel, chain);
+	}
+	printf("port %d: flow tunnel #%u type %s\n",
+		port_id, flow_tunnel->id, ops->type);
+}
+
 /** Generate a port_flow entry from attributes/pattern/actions. */
 static struct port_flow *
 port_flow_new(const struct rte_flow_attr *attr,
@@ -1503,13 +1555,15 @@ int
 port_flow_create(portid_t port_id,
 		 const struct rte_flow_attr *attr,
 		 const struct rte_flow_item *pattern,
-		 const struct rte_flow_action *actions)
+		 const struct rte_flow_action *actions,
+		 const struct tunnel_ops *tunnel_ops)
 {
 	struct rte_flow *flow;
 	struct rte_port *port;
 	struct port_flow *pf;
 	uint32_t id =3D 0;
 	struct rte_flow_error error;
+	struct port_flow_tunnel *pft;
=20
 	port =3D &ports[port_id];
 	if (port->flow_list) {
@@ -1520,6 +1574,75 @@ port_flow_create(portid_t port_id,
 		}
 		id =3D port->flow_list->id + 1;
 	}
+	if (tunnel_ops->enabled) {
+		int ret;
+		pft =3D port_flow_locate_tunnel(port, tunnel_ops->id);
+		if (!pft) {
+			printf("failed to locate port flow tunnel #%u\n",
+				tunnel_ops->id);
+			return -ENOENT;
+		}
+		if (tunnel_ops->actions) {
+			uint32_t num_actions;
+			const struct rte_flow_action *aptr;
+
+			ret =3D rte_flow_tunnel_decap_set(port_id, &pft->tunnel,
+							&pft->pmd_actions,
+							&pft->num_pmd_actions,
+							&error);
+			if (ret) {
+				port_flow_complain(&error);
+				return -EINVAL;
+			}
+			for (aptr =3D actions, num_actions =3D 1;
+			     aptr->type !=3D RTE_FLOW_ACTION_TYPE_END;
+			     aptr++, num_actions++);
+			pft->actions =3D malloc(
+					(num_actions +  pft->num_pmd_actions) *
+					sizeof(actions[0]));
+			if (!pft->actions) {
+				rte_flow_tunnel_action_decap_release(
+						port_id, pft->actions,
+						pft->num_pmd_actions, &error);
+				return -ENOMEM;
+			}
+			rte_memcpy(pft->actions, pft->pmd_actions,
+				   pft->num_pmd_actions * sizeof(actions[0]));
+			rte_memcpy(pft->actions + pft->num_pmd_actions, actions,
+				   num_actions * sizeof(actions[0]));
+			actions =3D pft->actions;
+		}
+		if (tunnel_ops->items) {
+			uint32_t num_items;
+			const struct rte_flow_item *iptr;
+
+			ret =3D rte_flow_tunnel_match(port_id, &pft->tunnel,
+						    &pft->pmd_items,
+						    &pft->num_pmd_items,
+						    &error);
+			if (ret) {
+				port_flow_complain(&error);
+				return -EINVAL;
+			}
+			for (iptr =3D pattern, num_items =3D 1;
+			     iptr->type !=3D RTE_FLOW_ITEM_TYPE_END;
+			     iptr++, num_items++);
+			pft->items =3D malloc((num_items + pft->num_pmd_items) *
+					    sizeof(pattern[0]));
+			if (!pft->items) {
+				rte_flow_tunnel_item_release(
+						port_id, pft->pmd_items,
+						pft->num_pmd_items, &error);
+				return -ENOMEM;
+			}
+			rte_memcpy(pft->items, pft->pmd_items,
+				   pft->num_pmd_items * sizeof(pattern[0]));
+			rte_memcpy(pft->items + pft->num_pmd_items, pattern,
+				   num_items * sizeof(pattern[0]));
+			pattern =3D pft->items;
+		}
+
+	}
 	pf =3D port_flow_new(attr, pattern, actions, &error);
 	if (!pf)
 		return port_flow_complain(&error);
@@ -1535,6 +1658,20 @@ port_flow_create(portid_t port_id,
 	pf->id =3D id;
 	pf->flow =3D flow;
 	port->flow_list =3D pf;
+	if (tunnel_ops->enabled) {
+		if (tunnel_ops->actions) {
+			free(pft->actions);
+			rte_flow_tunnel_action_decap_release(
+				port_id, pft->pmd_actions,
+				pft->num_pmd_actions, &error);
+		}
+		if (tunnel_ops->items) {
+			free(pft->items);
+			rte_flow_tunnel_item_release(port_id, pft->pmd_items,
+						     pft->num_pmd_items,
+						     &error);
+		}
+	}
 	printf("Flow rule #%u created\n", pf->id);
 	return 0;
 }
@@ -1829,7 +1966,9 @@ port_flow_list(portid_t port_id, uint32_t n, const ui=
nt32_t group[n])
 		       pf->rule.attr->egress ? 'e' : '-',
 		       pf->rule.attr->transfer ? 't' : '-');
 		while (item->type !=3D RTE_FLOW_ITEM_TYPE_END) {
-			if (rte_flow_conv(RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
+			if ((uint32_t)item->type > INT_MAX)
+				name =3D "PMD_INTERNAL";
+			else if (rte_flow_conv(RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
 					  &name, sizeof(name),
 					  (void *)(uintptr_t)item->type,
 					  NULL) <=3D 0)
@@ -1840,7 +1979,9 @@ port_flow_list(portid_t port_id, uint32_t n, const ui=
nt32_t group[n])
 		}
 		printf("=3D>");
 		while (action->type !=3D RTE_FLOW_ACTION_TYPE_END) {
-			if (rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
+			if ((uint32_t)action->type > INT_MAX)
+				name =3D "PMD_INTERNAL";
+			else if (rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
 					  &name, sizeof(name),
 					  (void *)(uintptr_t)action->type,
 					  NULL) <=3D 0)
diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index 7842c3b781..e2330116e1 100644
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -3591,6 +3591,8 @@ init_port_dcb_config(portid_t pid,
 static void
 init_port(void)
 {
+	int i;
+
 	/* Configuration of Ethernet ports. */
 	ports =3D rte_zmalloc("testpmd: ports",
 			    sizeof(struct rte_port) * RTE_MAX_ETHPORTS,
@@ -3600,7 +3602,8 @@ init_port(void)
 				"rte_zmalloc(%d struct rte_port) failed\n",
 				RTE_MAX_ETHPORTS);
 	}
-
+	for (i =3D 0; i < RTE_MAX_ETHPORTS; i++)
+		LIST_INIT(&ports[i].flow_tunnel_list);
 	/* Initialize ports NUMA structures */
 	memset(port_numa, NUMA_NO_CONFIG, RTE_MAX_ETHPORTS);
 	memset(rxring_numa, NUMA_NO_CONFIG, RTE_MAX_ETHPORTS);
diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index 25a12b14f2..9c47533c68 100644
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -12,6 +12,7 @@
 #include <rte_gro.h>
 #include <rte_gso.h>
 #include <cmdline.h>
+#include <sys/queue.h>
=20
 #define RTE_PORT_ALL            (~(portid_t)0x0)
=20
@@ -148,6 +149,26 @@ struct port_flow {
 	uint8_t data[]; /**< Storage for flow rule description */
 };
=20
+struct port_flow_tunnel {
+	LIST_ENTRY(port_flow_tunnel) chain;
+	struct rte_flow_action *pmd_actions;
+	struct rte_flow_item   *pmd_items;
+	uint32_t id;
+	uint32_t num_pmd_actions;
+	uint32_t num_pmd_items;
+	struct rte_flow_tunnel tunnel;
+	struct rte_flow_action *actions;
+	struct rte_flow_item *items;
+};
+
+struct tunnel_ops {
+	uint32_t id;
+	char type[16];
+	uint32_t enabled:1;
+	uint32_t actions:1;
+	uint32_t items:1;
+};
+
 /**
  * The data structure associated with each port.
  */
@@ -178,6 +199,7 @@ struct rte_port {
 	uint32_t                mc_addr_nb; /**< nb. of addr. in mc_addr_pool */
 	uint8_t                 slave_flag; /**< bonding slave port */
 	struct port_flow        *flow_list; /**< Associated flows. */
+	LIST_HEAD(, port_flow_tunnel) flow_tunnel_list;
 	const struct rte_eth_rxtx_callback *rx_dump_cb[RTE_MAX_QUEUES_PER_PORT+1]=
;
 	const struct rte_eth_rxtx_callback *tx_dump_cb[RTE_MAX_QUEUES_PER_PORT+1]=
;
 	/**< metadata value to insert in Tx packets. */
@@ -729,7 +751,8 @@ int port_flow_validate(portid_t port_id,
 int port_flow_create(portid_t port_id,
 		     const struct rte_flow_attr *attr,
 		     const struct rte_flow_item *pattern,
-		     const struct rte_flow_action *actions);
+		     const struct rte_flow_action *actions,
+		     const struct tunnel_ops *tunnel_ops);
 void update_age_action_context(const struct rte_flow_action *actions,
 		     struct port_flow *pf);
 int port_flow_destroy(portid_t port_id, uint32_t n, const uint32_t *rule);
@@ -739,6 +762,8 @@ int port_flow_query(portid_t port_id, uint32_t rule,
 		    const struct rte_flow_action *action);
 void port_flow_list(portid_t port_id, uint32_t n, const uint32_t *group);
 void port_flow_aged(portid_t port_id, uint8_t destroy);
+void port_flow_release_tunnel(struct port_flow_tunnel *flow_tunnel);
+void port_flow_add_tunnel(portid_t port_id, const struct tunnel_ops *ops);
 int port_flow_isolate(portid_t port_id, int set);
=20
 void rx_ring_desc_display(portid_t port_id, queueid_t rxq_id, uint16_t rxd=
_id);
diff --git a/app/test-pmd/util.c b/app/test-pmd/util.c
index 8488fa1a8f..6757acde9a 100644
--- a/app/test-pmd/util.c
+++ b/app/test-pmd/util.c
@@ -22,6 +22,12 @@ print_ether_addr(const char *what, const struct rte_ethe=
r_addr *eth_addr)
 	printf("%s%s", what, buf);
 }
=20
+static bool tunnel_missed_packet(struct rte_mbuf  *mb)
+{
+	uint64_t mask =3D PKT_RX_FDIR | PKT_RX_FDIR_ID;
+	return (mb->ol_flags & mask) =3D=3D mask;
+}
+
 static inline void
 dump_pkt_burst(uint16_t port_id, uint16_t queue, struct rte_mbuf *pkts[],
 	      uint16_t nb_pkts, int is_rx)
@@ -51,15 +57,37 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue, struct=
 rte_mbuf *pkts[],
 		mb =3D pkts[i];
 		eth_hdr =3D rte_pktmbuf_read(mb, 0, sizeof(_eth_hdr), &_eth_hdr);
 		eth_type =3D RTE_BE_TO_CPU_16(eth_hdr->ether_type);
-		ol_flags =3D mb->ol_flags;
 		packet_type =3D mb->packet_type;
 		is_encapsulation =3D RTE_ETH_IS_TUNNEL_PKT(packet_type);
=20
+		if (tunnel_missed_packet(mb)) {
+			int ret;
+			struct rte_flow_error error;
+			struct rte_flow_restore_info info =3D { 0, };
+
+			ret =3D rte_flow_tunnel_get_restore_info(port_id, mb,
+							       &info, &error);
+			if (!ret) {
+				printf("tunnel restore info:");
+				if (info.flags & RTE_FLOW_RESTORE_INFO_TUNNEL)
+					if (info.tunnel.type =3D=3D
+					    RTE_FLOW_ITEM_TYPE_VXLAN)
+						printf(" - vxlan tunnel");
+				if (info.flags &
+				    RTE_FLOW_RESTORE_INFO_ENCAPSULATED)
+					printf(" - outer header present");
+				if (info.flags & RTE_FLOW_RESTORE_INFO_GROUP_ID)
+					printf(" - miss group %u",
+						info.group_id);
+			}
+			printf("\n");
+		}
 		print_ether_addr("  src=3D", &eth_hdr->s_addr);
 		print_ether_addr(" - dst=3D", &eth_hdr->d_addr);
 		printf(" - type=3D0x%04x - length=3D%u - nb_segs=3D%d",
 		       eth_type, (unsigned int) mb->pkt_len,
 		       (int)mb->nb_segs);
+		ol_flags =3D mb->ol_flags;
 		if (ol_flags & PKT_RX_RSS_HASH) {
 			printf(" - RSS hash=3D0x%x", (unsigned int) mb->hash.rss);
 			printf(" - RSS queue=3D0x%x", (unsigned int) queue);
--=20
2.25.1